Celestin Apprentice 5/Apprentice-Release5.iso/Source Code/C/Applications/Python 1.3.3/Python 133 SRC/Mac/Modules/qt/Qtmodule.c

Text File | 1996-04-12 | 164KB | 6,011 lines

/* =========================== Module Qt ============================ */

#include "Python.h"



#define SystemSevenOrLater 1

#include "macglue.h"
#include <Memory.h>
#include <Dialogs.h>
#include <Menus.h>
#include <Controls.h>

extern PyObject *ResObj_New(Handle);
extern int ResObj_Convert(PyObject *, Handle *);
extern PyObject *OptResObj_New(Handle);
extern int OptResObj_Convert(PyObject *, Handle *);

extern PyObject *WinObj_New(WindowPtr);
extern int WinObj_Convert(PyObject *, WindowPtr *);
extern PyTypeObject Window_Type;
#define WinObj_Check(x) ((x)->ob_type == &Window_Type)

extern PyObject *DlgObj_New(DialogPtr);
extern int DlgObj_Convert(PyObject *, DialogPtr *);
extern PyTypeObject Dialog_Type;
#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)

extern PyObject *MenuObj_New(MenuHandle);
extern int MenuObj_Convert(PyObject *, MenuHandle *);

extern PyObject *CtlObj_New(ControlHandle);
extern int CtlObj_Convert(PyObject *, ControlHandle *);

extern PyObject *GrafObj_New(GrafPtr);
extern int GrafObj_Convert(PyObject *, GrafPtr *);

extern PyObject *BMObj_New(BitMapPtr);
extern int BMObj_Convert(PyObject *, BitMapPtr *);

extern PyObject *PMObj_New(PixMapHandle);
extern int PMObj_Convert(PyObject *, PixMapHandle *);

extern PyObject *WinObj_WhichWindow(WindowPtr);

#include <Movies.h>

/* Exported by Cmmodule.c: */
extern PyObject *CmpObj_New(Component);
extern int CmpObj_Convert(PyObject *, Component *);
extern PyObject *CmpInstObj_New(ComponentInstance);
extern int CmpInstObj_Convert(PyObject *, ComponentInstance *);

/* Exported by Qdmodule.c: */
extern PyObject *QdRGB_New(RGBColor *);
extern int QdRGB_Convert(PyObject *, RGBColor *);

/* Our own, used before defined: */
staticforward PyObject *TrackObj_New(Track);
staticforward int TrackObj_Convert(PyObject *, Track *);
staticforward PyObject *MovieObj_New(Movie);
staticforward int MovieObj_Convert(PyObject *, Movie *);
staticforward PyObject *MovieCtlObj_New(MovieController);
staticforward int MovieCtlObj_Convert(PyObject *, MovieController *);



static PyObject *Qt_Error;

/* ------------------ Object type MovieController ------------------- */

PyTypeObject MovieController_Type;

#define MovieCtlObj_Check(x) ((x)->ob_type == &MovieController_Type)

typedef struct MovieControllerObject {
    PyObject_HEAD
    MovieController ob_itself;
} MovieControllerObject;

PyObject *MovieCtlObj_New(itself)
    MovieController itself;
{
    MovieControllerObject *it;
    if (itself == NULL) {
                        PyErr_SetString(Qt_Error,"Cannot create null MovieController");
                        return NULL;
                    }
    it = PyObject_NEW(MovieControllerObject, &MovieController_Type);
    if (it == NULL) return NULL;
    it->ob_itself = itself;
    return (PyObject *)it;
}
MovieCtlObj_Convert(v, p_itself)
    PyObject *v;
    MovieController *p_itself;
{
    if (!MovieCtlObj_Check(v))
    {
        PyErr_SetString(PyExc_TypeError, "MovieController required");
        return 0;
    }
    *p_itself = ((MovieControllerObject *)v)->ob_itself;
    return 1;
}

static void MovieCtlObj_dealloc(self)
    MovieControllerObject *self;
{
    DisposeMovieController(self->ob_itself);
    PyMem_DEL(self);
}

static PyObject *MovieCtlObj_MCSetMovie(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Movie theMovie;
    WindowPtr movieWindow;
    Point where;
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          MovieObj_Convert, &theMovie,
                          WinObj_Convert, &movieWindow,
                          PyMac_GetPoint, &where))
        return NULL;
    _rv = MCSetMovie(_self->ob_itself,
                     theMovie,
                     movieWindow,
                     where);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetIndMovie(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Movie _rv;
    short index;
    if (!PyArg_ParseTuple(_args, "h",
                          &index))
        return NULL;
    _rv = MCGetIndMovie(_self->ob_itself,
                        index);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCRemoveMovie(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCRemoveMovie(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCIsPlayerEvent(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    EventRecord e;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetEventRecord, &e))
        return NULL;
    _rv = MCIsPlayerEvent(_self->ob_itself,
                          &e);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCDoAction(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    short action;
    void * params;
    if (!PyArg_ParseTuple(_args, "hs",
                          &action,
                          ¶ms))
        return NULL;
    _rv = MCDoAction(_self->ob_itself,
                     action,
                     params);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCSetControllerAttached(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Boolean attach;
    if (!PyArg_ParseTuple(_args, "b",
                          &attach))
        return NULL;
    _rv = MCSetControllerAttached(_self->ob_itself,
                                  attach);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCIsControllerAttached(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCIsControllerAttached(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCSetVisible(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Boolean visible;
    if (!PyArg_ParseTuple(_args, "b",
                          &visible))
        return NULL;
    _rv = MCSetVisible(_self->ob_itself,
                       visible);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetVisible(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCGetVisible(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetControllerBoundsRect(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Rect bounds;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCGetControllerBoundsRect(_self->ob_itself,
                                    &bounds);
    _res = Py_BuildValue("lO&",
                         _rv,
                         PyMac_BuildRect, &bounds);
    return _res;
}

static PyObject *MovieCtlObj_MCSetControllerBoundsRect(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Rect bounds;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetRect, &bounds))
        return NULL;
    _rv = MCSetControllerBoundsRect(_self->ob_itself,
                                    &bounds);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetControllerBoundsRgn(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCGetControllerBoundsRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetWindowRgn(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    WindowPtr w;
    if (!PyArg_ParseTuple(_args, "O&",
                          WinObj_Convert, &w))
        return NULL;
    _rv = MCGetWindowRgn(_self->ob_itself,
                         w);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCMovieChanged(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Movie m;
    if (!PyArg_ParseTuple(_args, "O&",
                          MovieObj_Convert, &m))
        return NULL;
    _rv = MCMovieChanged(_self->ob_itself,
                         m);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCSetDuration(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    TimeValue duration;
    if (!PyArg_ParseTuple(_args, "l",
                          &duration))
        return NULL;
    _rv = MCSetDuration(_self->ob_itself,
                        duration);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetCurrentTime(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue _rv;
    TimeScale scale;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCGetCurrentTime(_self->ob_itself,
                           &scale);
    _res = Py_BuildValue("ll",
                         _rv,
                         scale);
    return _res;
}

static PyObject *MovieCtlObj_MCNewAttachedController(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Movie theMovie;
    WindowPtr w;
    Point where;
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          MovieObj_Convert, &theMovie,
                          WinObj_Convert, &w,
                          PyMac_GetPoint, &where))
        return NULL;
    _rv = MCNewAttachedController(_self->ob_itself,
                                  theMovie,
                                  w,
                                  where);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCDraw(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    WindowPtr w;
    if (!PyArg_ParseTuple(_args, "O&",
                          WinObj_Convert, &w))
        return NULL;
    _rv = MCDraw(_self->ob_itself,
                 w);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCActivate(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    WindowPtr w;
    Boolean activate;
    if (!PyArg_ParseTuple(_args, "O&b",
                          WinObj_Convert, &w,
                          &activate))
        return NULL;
    _rv = MCActivate(_self->ob_itself,
                     w,
                     activate);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCIdle(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCIdle(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCKey(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    SInt8 key;
    long modifiers;
    if (!PyArg_ParseTuple(_args, "bl",
                          &key,
                          &modifiers))
        return NULL;
    _rv = MCKey(_self->ob_itself,
                key,
                modifiers);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCClick(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    WindowPtr w;
    Point where;
    long when;
    long modifiers;
    if (!PyArg_ParseTuple(_args, "O&O&ll",
                          WinObj_Convert, &w,
                          PyMac_GetPoint, &where,
                          &when,
                          &modifiers))
        return NULL;
    _rv = MCClick(_self->ob_itself,
                  w,
                  where,
                  when,
                  modifiers);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCEnableEditing(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Boolean enabled;
    if (!PyArg_ParseTuple(_args, "b",
                          &enabled))
        return NULL;
    _rv = MCEnableEditing(_self->ob_itself,
                          enabled);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCIsEditingEnabled(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCIsEditingEnabled(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCCopy(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Movie _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCCopy(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCCut(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Movie _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCCut(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCPaste(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Movie srcMovie;
    if (!PyArg_ParseTuple(_args, "O&",
                          MovieObj_Convert, &srcMovie))
        return NULL;
    _rv = MCPaste(_self->ob_itself,
                  srcMovie);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCClear(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCClear(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCUndo(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCUndo(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCPositionController(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Rect movieRect;
    Rect controllerRect;
    long someFlags;
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          PyMac_GetRect, &movieRect,
                          PyMac_GetRect, &controllerRect,
                          &someFlags))
        return NULL;
    _rv = MCPositionController(_self->ob_itself,
                               &movieRect,
                               &controllerRect,
                               someFlags);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetControllerInfo(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    long someFlags;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCGetControllerInfo(_self->ob_itself,
                              &someFlags);
    _res = Py_BuildValue("ll",
                         _rv,
                         someFlags);
    return _res;
}

static PyObject *MovieCtlObj_MCSetClip(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    RgnHandle theClip;
    RgnHandle movieClip;
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &theClip,
                          ResObj_Convert, &movieClip))
        return NULL;
    _rv = MCSetClip(_self->ob_itself,
                    theClip,
                    movieClip);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetClip(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    RgnHandle theClip;
    RgnHandle movieClip;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MCGetClip(_self->ob_itself,
                    &theClip,
                    &movieClip);
    _res = Py_BuildValue("lO&O&",
                         _rv,
                         ResObj_New, theClip,
                         ResObj_New, movieClip);
    return _res;
}

static PyObject *MovieCtlObj_MCDrawBadge(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    RgnHandle movieRgn;
    RgnHandle badgeRgn;
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &movieRgn))
        return NULL;
    _rv = MCDrawBadge(_self->ob_itself,
                      movieRgn,
                      &badgeRgn);
    _res = Py_BuildValue("lO&",
                         _rv,
                         ResObj_New, badgeRgn);
    return _res;
}

static PyObject *MovieCtlObj_MCSetUpEditMenu(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    long modifiers;
    MenuHandle mh;
    if (!PyArg_ParseTuple(_args, "lO&",
                          &modifiers,
                          MenuObj_Convert, &mh))
        return NULL;
    _rv = MCSetUpEditMenu(_self->ob_itself,
                          modifiers,
                          mh);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieCtlObj_MCGetMenuString(_self, _args)
    MovieControllerObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    long modifiers;
    short item;
    Str255 aString;
    if (!PyArg_ParseTuple(_args, "lhO&",
                          &modifiers,
                          &item,
                          PyMac_GetStr255, aString))
        return NULL;
    _rv = MCGetMenuString(_self->ob_itself,
                          modifiers,
                          item,
                          aString);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyMethodDef MovieCtlObj_methods[] = {
    {"MCSetMovie", (PyCFunction)MovieCtlObj_MCSetMovie, 1,
     "(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)"},
    {"MCGetIndMovie", (PyCFunction)MovieCtlObj_MCGetIndMovie, 1,
     "(short index) -> (Movie _rv)"},
    {"MCRemoveMovie", (PyCFunction)MovieCtlObj_MCRemoveMovie, 1,
     "() -> (ComponentResult _rv)"},
    {"MCIsPlayerEvent", (PyCFunction)MovieCtlObj_MCIsPlayerEvent, 1,
     "(EventRecord e) -> (ComponentResult _rv)"},
    {"MCDoAction", (PyCFunction)MovieCtlObj_MCDoAction, 1,
     "(short action, void * params) -> (ComponentResult _rv)"},
    {"MCSetControllerAttached", (PyCFunction)MovieCtlObj_MCSetControllerAttached, 1,
     "(Boolean attach) -> (ComponentResult _rv)"},
    {"MCIsControllerAttached", (PyCFunction)MovieCtlObj_MCIsControllerAttached, 1,
     "() -> (ComponentResult _rv)"},
    {"MCSetVisible", (PyCFunction)MovieCtlObj_MCSetVisible, 1,
     "(Boolean visible) -> (ComponentResult _rv)"},
    {"MCGetVisible", (PyCFunction)MovieCtlObj_MCGetVisible, 1,
     "() -> (ComponentResult _rv)"},
    {"MCGetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRect, 1,
     "() -> (ComponentResult _rv, Rect bounds)"},
    {"MCSetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCSetControllerBoundsRect, 1,
     "(Rect bounds) -> (ComponentResult _rv)"},
    {"MCGetControllerBoundsRgn", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRgn, 1,
     "() -> (RgnHandle _rv)"},
    {"MCGetWindowRgn", (PyCFunction)MovieCtlObj_MCGetWindowRgn, 1,
     "(WindowPtr w) -> (RgnHandle _rv)"},
    {"MCMovieChanged", (PyCFunction)MovieCtlObj_MCMovieChanged, 1,
     "(Movie m) -> (ComponentResult _rv)"},
    {"MCSetDuration", (PyCFunction)MovieCtlObj_MCSetDuration, 1,
     "(TimeValue duration) -> (ComponentResult _rv)"},
    {"MCGetCurrentTime", (PyCFunction)MovieCtlObj_MCGetCurrentTime, 1,
     "() -> (TimeValue _rv, TimeScale scale)"},
    {"MCNewAttachedController", (PyCFunction)MovieCtlObj_MCNewAttachedController, 1,
     "(Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)"},
    {"MCDraw", (PyCFunction)MovieCtlObj_MCDraw, 1,
     "(WindowPtr w) -> (ComponentResult _rv)"},
    {"MCActivate", (PyCFunction)MovieCtlObj_MCActivate, 1,
     "(WindowPtr w, Boolean activate) -> (ComponentResult _rv)"},
    {"MCIdle", (PyCFunction)MovieCtlObj_MCIdle, 1,
     "() -> (ComponentResult _rv)"},
    {"MCKey", (PyCFunction)MovieCtlObj_MCKey, 1,
     "(SInt8 key, long modifiers) -> (ComponentResult _rv)"},
    {"MCClick", (PyCFunction)MovieCtlObj_MCClick, 1,
     "(WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)"},
    {"MCEnableEditing", (PyCFunction)MovieCtlObj_MCEnableEditing, 1,
     "(Boolean enabled) -> (ComponentResult _rv)"},
    {"MCIsEditingEnabled", (PyCFunction)MovieCtlObj_MCIsEditingEnabled, 1,
     "() -> (long _rv)"},
    {"MCCopy", (PyCFunction)MovieCtlObj_MCCopy, 1,
     "() -> (Movie _rv)"},
    {"MCCut", (PyCFunction)MovieCtlObj_MCCut, 1,
     "() -> (Movie _rv)"},
    {"MCPaste", (PyCFunction)MovieCtlObj_MCPaste, 1,
     "(Movie srcMovie) -> (ComponentResult _rv)"},
    {"MCClear", (PyCFunction)MovieCtlObj_MCClear, 1,
     "() -> (ComponentResult _rv)"},
    {"MCUndo", (PyCFunction)MovieCtlObj_MCUndo, 1,
     "() -> (ComponentResult _rv)"},
    {"MCPositionController", (PyCFunction)MovieCtlObj_MCPositionController, 1,
     "(Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)"},
    {"MCGetControllerInfo", (PyCFunction)MovieCtlObj_MCGetControllerInfo, 1,
     "() -> (ComponentResult _rv, long someFlags)"},
    {"MCSetClip", (PyCFunction)MovieCtlObj_MCSetClip, 1,
     "(RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)"},
    {"MCGetClip", (PyCFunction)MovieCtlObj_MCGetClip, 1,
     "() -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)"},
    {"MCDrawBadge", (PyCFunction)MovieCtlObj_MCDrawBadge, 1,
     "(RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)"},
    {"MCSetUpEditMenu", (PyCFunction)MovieCtlObj_MCSetUpEditMenu, 1,
     "(long modifiers, MenuHandle mh) -> (ComponentResult _rv)"},
    {"MCGetMenuString", (PyCFunction)MovieCtlObj_MCGetMenuString, 1,
     "(long modifiers, short item, Str255 aString) -> (ComponentResult _rv)"},
    {NULL, NULL, 0}
};

PyMethodChain MovieCtlObj_chain = { MovieCtlObj_methods, NULL };

static PyObject *MovieCtlObj_getattr(self, name)
    MovieControllerObject *self;
    char *name;
{
    return Py_FindMethodInChain(&MovieCtlObj_chain, (PyObject *)self, name);
}

#define MovieCtlObj_setattr NULL

PyTypeObject MovieController_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0, /*ob_size*/
    "MovieController", /*tp_name*/
    sizeof(MovieControllerObject), /*tp_basicsize*/
    0, /*tp_itemsize*/
    /* methods */
    (destructor) MovieCtlObj_dealloc, /*tp_dealloc*/
    0, /*tp_print*/
    (getattrfunc) MovieCtlObj_getattr, /*tp_getattr*/
    (setattrfunc) MovieCtlObj_setattr, /*tp_setattr*/
};

/* ---------------- End object type MovieController ----------------- */


/* ---------------------- Object type TimeBase ---------------------- */

PyTypeObject TimeBase_Type;

#define TimeBaseObj_Check(x) ((x)->ob_type == &TimeBase_Type)

typedef struct TimeBaseObject {
    PyObject_HEAD
    TimeBase ob_itself;
} TimeBaseObject;

PyObject *TimeBaseObj_New(itself)
    TimeBase itself;
{
    TimeBaseObject *it;
    if (itself == NULL) {
                        PyErr_SetString(Qt_Error,"Cannot create null TimeBase");
                        return NULL;
                    }
    it = PyObject_NEW(TimeBaseObject, &TimeBase_Type);
    if (it == NULL) return NULL;
    it->ob_itself = itself;
    return (PyObject *)it;
}
TimeBaseObj_Convert(v, p_itself)
    PyObject *v;
    TimeBase *p_itself;
{
    if (!TimeBaseObj_Check(v))
    {
        PyErr_SetString(PyExc_TypeError, "TimeBase required");
        return 0;
    }
    *p_itself = ((TimeBaseObject *)v)->ob_itself;
    return 1;
}

static void TimeBaseObj_dealloc(self)
    TimeBaseObject *self;
{
    DisposeTimeBase(self->ob_itself);
    PyMem_DEL(self);
}

static PyObject *TimeBaseObj_SetTimeBaseValue(_self, _args)
    TimeBaseObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue t;
    TimeScale s;
    if (!PyArg_ParseTuple(_args, "ll",
                          &t,
                          &s))
        return NULL;
    SetTimeBaseValue(_self->ob_itself,
                     t,
                     s);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TimeBaseObj_GetTimeBaseRate(_self, _args)
    TimeBaseObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Fixed _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTimeBaseRate(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *TimeBaseObj_SetTimeBaseRate(_self, _args)
    TimeBaseObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Fixed r;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetFixed, &r))
        return NULL;
    SetTimeBaseRate(_self->ob_itself,
                    r);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TimeBaseObj_GetTimeBaseFlags(_self, _args)
    TimeBaseObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTimeBaseFlags(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *TimeBaseObj_SetTimeBaseFlags(_self, _args)
    TimeBaseObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long timeBaseFlags;
    if (!PyArg_ParseTuple(_args, "l",
                          &timeBaseFlags))
        return NULL;
    SetTimeBaseFlags(_self->ob_itself,
                     timeBaseFlags);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TimeBaseObj_GetTimeBaseMasterTimeBase(_self, _args)
    TimeBaseObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeBase _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTimeBaseMasterTimeBase(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         TimeBaseObj_New, _rv);
    return _res;
}

static PyObject *TimeBaseObj_GetTimeBaseMasterClock(_self, _args)
    TimeBaseObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentInstance _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTimeBaseMasterClock(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         CmpInstObj_New, _rv);
    return _res;
}

static PyObject *TimeBaseObj_GetTimeBaseEffectiveRate(_self, _args)
    TimeBaseObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Fixed _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTimeBaseEffectiveRate(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyMethodDef TimeBaseObj_methods[] = {
    {"SetTimeBaseValue", (PyCFunction)TimeBaseObj_SetTimeBaseValue, 1,
     "(TimeValue t, TimeScale s) -> None"},
    {"GetTimeBaseRate", (PyCFunction)TimeBaseObj_GetTimeBaseRate, 1,
     "() -> (Fixed _rv)"},
    {"SetTimeBaseRate", (PyCFunction)TimeBaseObj_SetTimeBaseRate, 1,
     "(Fixed r) -> None"},
    {"GetTimeBaseFlags", (PyCFunction)TimeBaseObj_GetTimeBaseFlags, 1,
     "() -> (long _rv)"},
    {"SetTimeBaseFlags", (PyCFunction)TimeBaseObj_SetTimeBaseFlags, 1,
     "(long timeBaseFlags) -> None"},
    {"GetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_GetTimeBaseMasterTimeBase, 1,
     "() -> (TimeBase _rv)"},
    {"GetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_GetTimeBaseMasterClock, 1,
     "() -> (ComponentInstance _rv)"},
    {"GetTimeBaseEffectiveRate", (PyCFunction)TimeBaseObj_GetTimeBaseEffectiveRate, 1,
     "() -> (Fixed _rv)"},
    {NULL, NULL, 0}
};

PyMethodChain TimeBaseObj_chain = { TimeBaseObj_methods, NULL };

static PyObject *TimeBaseObj_getattr(self, name)
    TimeBaseObject *self;
    char *name;
{
    return Py_FindMethodInChain(&TimeBaseObj_chain, (PyObject *)self, name);
}

#define TimeBaseObj_setattr NULL

PyTypeObject TimeBase_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0, /*ob_size*/
    "TimeBase", /*tp_name*/
    sizeof(TimeBaseObject), /*tp_basicsize*/
    0, /*tp_itemsize*/
    /* methods */
    (destructor) TimeBaseObj_dealloc, /*tp_dealloc*/
    0, /*tp_print*/
    (getattrfunc) TimeBaseObj_getattr, /*tp_getattr*/
    (setattrfunc) TimeBaseObj_setattr, /*tp_setattr*/
};

/* -------------------- End object type TimeBase -------------------- */


/* ---------------------- Object type UserData ---------------------- */

PyTypeObject UserData_Type;

#define UserDataObj_Check(x) ((x)->ob_type == &UserData_Type)

typedef struct UserDataObject {
    PyObject_HEAD
    UserData ob_itself;
} UserDataObject;

PyObject *UserDataObj_New(itself)
    UserData itself;
{
    UserDataObject *it;
    if (itself == NULL) {
                        PyErr_SetString(Qt_Error,"Cannot create null UserData");
                        return NULL;
                    }
    it = PyObject_NEW(UserDataObject, &UserData_Type);
    if (it == NULL) return NULL;
    it->ob_itself = itself;
    return (PyObject *)it;
}
UserDataObj_Convert(v, p_itself)
    PyObject *v;
    UserData *p_itself;
{
    if (!UserDataObj_Check(v))
    {
        PyErr_SetString(PyExc_TypeError, "UserData required");
        return 0;
    }
    *p_itself = ((UserDataObject *)v)->ob_itself;
    return 1;
}

static void UserDataObj_dealloc(self)
    UserDataObject *self;
{
    DisposeUserData(self->ob_itself);
    PyMem_DEL(self);
}

static PyObject *UserDataObj_GetUserData(_self, _args)
    UserDataObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle data;
    OSType udType;
    long index;
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          ResObj_Convert, &data,
                          PyMac_GetOSType, &udType,
                          &index))
        return NULL;
    _err = GetUserData(_self->ob_itself,
                       data,
                       udType,
                       index);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *UserDataObj_AddUserData(_self, _args)
    UserDataObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle data;
    OSType udType;
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &data,
                          PyMac_GetOSType, &udType))
        return NULL;
    _err = AddUserData(_self->ob_itself,
                       data,
                       udType);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *UserDataObj_RemoveUserData(_self, _args)
    UserDataObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    OSType udType;
    long index;
    if (!PyArg_ParseTuple(_args, "O&l",
                          PyMac_GetOSType, &udType,
                          &index))
        return NULL;
    _err = RemoveUserData(_self->ob_itself,
                          udType,
                          index);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *UserDataObj_CountUserDataType(_self, _args)
    UserDataObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short _rv;
    OSType udType;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetOSType, &udType))
        return NULL;
    _rv = CountUserDataType(_self->ob_itself,
                            udType);
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *UserDataObj_GetNextUserDataType(_self, _args)
    UserDataObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long _rv;
    OSType udType;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetOSType, &udType))
        return NULL;
    _rv = GetNextUserDataType(_self->ob_itself,
                              udType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *UserDataObj_AddUserDataText(_self, _args)
    UserDataObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle data;
    OSType udType;
    long index;
    short itlRegionTag;
    if (!PyArg_ParseTuple(_args, "O&O&lh",
                          ResObj_Convert, &data,
                          PyMac_GetOSType, &udType,
                          &index,
                          &itlRegionTag))
        return NULL;
    _err = AddUserDataText(_self->ob_itself,
                           data,
                           udType,
                           index,
                           itlRegionTag);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *UserDataObj_GetUserDataText(_self, _args)
    UserDataObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle data;
    OSType udType;
    long index;
    short itlRegionTag;
    if (!PyArg_ParseTuple(_args, "O&O&lh",
                          ResObj_Convert, &data,
                          PyMac_GetOSType, &udType,
                          &index,
                          &itlRegionTag))
        return NULL;
    _err = GetUserDataText(_self->ob_itself,
                           data,
                           udType,
                           index,
                           itlRegionTag);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *UserDataObj_RemoveUserDataText(_self, _args)
    UserDataObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    OSType udType;
    long index;
    short itlRegionTag;
    if (!PyArg_ParseTuple(_args, "O&lh",
                          PyMac_GetOSType, &udType,
                          &index,
                          &itlRegionTag))
        return NULL;
    _err = RemoveUserDataText(_self->ob_itself,
                              udType,
                              index,
                              itlRegionTag);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *UserDataObj_PutUserDataIntoHandle(_self, _args)
    UserDataObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle h;
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &h))
        return NULL;
    _err = PutUserDataIntoHandle(_self->ob_itself,
                                 h);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyMethodDef UserDataObj_methods[] = {
    {"GetUserData", (PyCFunction)UserDataObj_GetUserData, 1,
     "(Handle data, OSType udType, long index) -> None"},
    {"AddUserData", (PyCFunction)UserDataObj_AddUserData, 1,
     "(Handle data, OSType udType) -> None"},
    {"RemoveUserData", (PyCFunction)UserDataObj_RemoveUserData, 1,
     "(OSType udType, long index) -> None"},
    {"CountUserDataType", (PyCFunction)UserDataObj_CountUserDataType, 1,
     "(OSType udType) -> (short _rv)"},
    {"GetNextUserDataType", (PyCFunction)UserDataObj_GetNextUserDataType, 1,
     "(OSType udType) -> (long _rv)"},
    {"AddUserDataText", (PyCFunction)UserDataObj_AddUserDataText, 1,
     "(Handle data, OSType udType, long index, short itlRegionTag) -> None"},
    {"GetUserDataText", (PyCFunction)UserDataObj_GetUserDataText, 1,
     "(Handle data, OSType udType, long index, short itlRegionTag) -> None"},
    {"RemoveUserDataText", (PyCFunction)UserDataObj_RemoveUserDataText, 1,
     "(OSType udType, long index, short itlRegionTag) -> None"},
    {"PutUserDataIntoHandle", (PyCFunction)UserDataObj_PutUserDataIntoHandle, 1,
     "(Handle h) -> None"},
    {NULL, NULL, 0}
};

PyMethodChain UserDataObj_chain = { UserDataObj_methods, NULL };

static PyObject *UserDataObj_getattr(self, name)
    UserDataObject *self;
    char *name;
{
    return Py_FindMethodInChain(&UserDataObj_chain, (PyObject *)self, name);
}

#define UserDataObj_setattr NULL

PyTypeObject UserData_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0, /*ob_size*/
    "UserData", /*tp_name*/
    sizeof(UserDataObject), /*tp_basicsize*/
    0, /*tp_itemsize*/
    /* methods */
    (destructor) UserDataObj_dealloc, /*tp_dealloc*/
    0, /*tp_print*/
    (getattrfunc) UserDataObj_getattr, /*tp_getattr*/
    (setattrfunc) UserDataObj_setattr, /*tp_setattr*/
};

/* -------------------- End object type UserData -------------------- */


/* ----------------------- Object type Media ------------------------ */

PyTypeObject Media_Type;

#define MediaObj_Check(x) ((x)->ob_type == &Media_Type)

typedef struct MediaObject {
    PyObject_HEAD
    Media ob_itself;
} MediaObject;

PyObject *MediaObj_New(itself)
    Media itself;
{
    MediaObject *it;
    if (itself == NULL) {
                        PyErr_SetString(Qt_Error,"Cannot create null Media");
                        return NULL;
                    }
    it = PyObject_NEW(MediaObject, &Media_Type);
    if (it == NULL) return NULL;
    it->ob_itself = itself;
    return (PyObject *)it;
}
MediaObj_Convert(v, p_itself)
    PyObject *v;
    Media *p_itself;
{
    if (!MediaObj_Check(v))
    {
        PyErr_SetString(PyExc_TypeError, "Media required");
        return 0;
    }
    *p_itself = ((MediaObject *)v)->ob_itself;
    return 1;
}

static void MediaObj_dealloc(self)
    MediaObject *self;
{
    DisposeTrackMedia(self->ob_itself);
    PyMem_DEL(self);
}

static PyObject *MediaObj_LoadMediaIntoRam(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue time;
    TimeValue duration;
    long flags;
    if (!PyArg_ParseTuple(_args, "lll",
                          &time,
                          &duration,
                          &flags))
        return NULL;
    _err = LoadMediaIntoRam(_self->ob_itself,
                            time,
                            duration,
                            flags);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaTrack(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Track _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMediaTrack(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *MediaObj_GetMediaTimeScale(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeScale _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMediaTimeScale(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MediaObj_SetMediaTimeScale(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeScale timeScale;
    if (!PyArg_ParseTuple(_args, "l",
                          &timeScale))
        return NULL;
    SetMediaTimeScale(_self->ob_itself,
                      timeScale);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaDuration(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMediaDuration(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MediaObj_GetMediaLanguage(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMediaLanguage(_self->ob_itself);
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *MediaObj_SetMediaLanguage(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short language;
    if (!PyArg_ParseTuple(_args, "h",
                          &language))
        return NULL;
    SetMediaLanguage(_self->ob_itself,
                     language);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaQuality(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMediaQuality(_self->ob_itself);
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *MediaObj_SetMediaQuality(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short quality;
    if (!PyArg_ParseTuple(_args, "h",
                          &quality))
        return NULL;
    SetMediaQuality(_self->ob_itself,
                    quality);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaHandlerDescription(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSType mediaType;
    Str255 creatorName;
    OSType creatorManufacturer;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetStr255, creatorName))
        return NULL;
    GetMediaHandlerDescription(_self->ob_itself,
                               &mediaType,
                               creatorName,
                               &creatorManufacturer);
    _res = Py_BuildValue("O&O&",
                         PyMac_BuildOSType, mediaType,
                         PyMac_BuildOSType, creatorManufacturer);
    return _res;
}

static PyObject *MediaObj_GetMediaUserData(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    UserData _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMediaUserData(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         UserDataObj_New, _rv);
    return _res;
}

static PyObject *MediaObj_GetMediaHandler(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    MediaHandler _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMediaHandler(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         CmpInstObj_New, _rv);
    return _res;
}

static PyObject *MediaObj_SetMediaHandler(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    MediaHandlerComponent mH;
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpObj_Convert, &mH))
        return NULL;
    _err = SetMediaHandler(_self->ob_itself,
                           mH);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_BeginMediaEdits(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = BeginMediaEdits(_self->ob_itself);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_EndMediaEdits(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = EndMediaEdits(_self->ob_itself);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_SetMediaDefaultDataRefIndex(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    short index;
    if (!PyArg_ParseTuple(_args, "h",
                          &index))
        return NULL;
    _err = SetMediaDefaultDataRefIndex(_self->ob_itself,
                                       index);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaDataHandlerDescription(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short index;
    OSType dhType;
    Str255 creatorName;
    OSType creatorManufacturer;
    if (!PyArg_ParseTuple(_args, "hO&",
                          &index,
                          PyMac_GetStr255, creatorName))
        return NULL;
    GetMediaDataHandlerDescription(_self->ob_itself,
                                   index,
                                   &dhType,
                                   creatorName,
                                   &creatorManufacturer);
    _res = Py_BuildValue("O&O&",
                         PyMac_BuildOSType, dhType,
                         PyMac_BuildOSType, creatorManufacturer);
    return _res;
}

static PyObject *MediaObj_GetMediaDataHandler(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    DataHandler _rv;
    short index;
    if (!PyArg_ParseTuple(_args, "h",
                          &index))
        return NULL;
    _rv = GetMediaDataHandler(_self->ob_itself,
                              index);
    _res = Py_BuildValue("O&",
                         CmpInstObj_New, _rv);
    return _res;
}

static PyObject *MediaObj_SetMediaDataHandler(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    short index;
    DataHandlerComponent dataHandler;
    if (!PyArg_ParseTuple(_args, "hO&",
                          &index,
                          CmpObj_Convert, &dataHandler))
        return NULL;
    _err = SetMediaDataHandler(_self->ob_itself,
                               index,
                               dataHandler);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaSampleDescriptionCount(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMediaSampleDescriptionCount(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MediaObj_GetMediaSampleDescription(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long index;
    SampleDescriptionHandle descH;
    if (!PyArg_ParseTuple(_args, "lO&",
                          &index,
                          ResObj_Convert, &descH))
        return NULL;
    GetMediaSampleDescription(_self->ob_itself,
                              index,
                              descH);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_SetMediaSampleDescription(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    long index;
    SampleDescriptionHandle descH;
    if (!PyArg_ParseTuple(_args, "lO&",
                          &index,
                          ResObj_Convert, &descH))
        return NULL;
    _err = SetMediaSampleDescription(_self->ob_itself,
                                     index,
                                     descH);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaSampleCount(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMediaSampleCount(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MediaObj_SampleNumToMediaTime(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long logicalSampleNum;
    TimeValue sampleTime;
    TimeValue sampleDuration;
    if (!PyArg_ParseTuple(_args, "l",
                          &logicalSampleNum))
        return NULL;
    SampleNumToMediaTime(_self->ob_itself,
                         logicalSampleNum,
                         &sampleTime,
                         &sampleDuration);
    _res = Py_BuildValue("ll",
                         sampleTime,
                         sampleDuration);
    return _res;
}

static PyObject *MediaObj_MediaTimeToSampleNum(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue time;
    long sampleNum;
    TimeValue sampleTime;
    TimeValue sampleDuration;
    if (!PyArg_ParseTuple(_args, "l",
                          &time))
        return NULL;
    MediaTimeToSampleNum(_self->ob_itself,
                         time,
                         &sampleNum,
                         &sampleTime,
                         &sampleDuration);
    _res = Py_BuildValue("lll",
                         sampleNum,
                         sampleTime,
                         sampleDuration);
    return _res;
}

static PyObject *MediaObj_AddMediaSample(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataIn;
    long inOffset;
    unsigned long size;
    TimeValue durationPerSample;
    SampleDescriptionHandle sampleDescriptionH;
    long numberOfSamples;
    short sampleFlags;
    TimeValue sampleTime;
    if (!PyArg_ParseTuple(_args, "O&lllO&lh",
                          ResObj_Convert, &dataIn,
                          &inOffset,
                          &size,
                          &durationPerSample,
                          ResObj_Convert, &sampleDescriptionH,
                          &numberOfSamples,
                          &sampleFlags))
        return NULL;
    _err = AddMediaSample(_self->ob_itself,
                          dataIn,
                          inOffset,
                          size,
                          durationPerSample,
                          sampleDescriptionH,
                          numberOfSamples,
                          sampleFlags,
                          &sampleTime);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         sampleTime);
    return _res;
}

static PyObject *MediaObj_AddMediaSampleReference(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    long dataOffset;
    unsigned long size;
    TimeValue durationPerSample;
    SampleDescriptionHandle sampleDescriptionH;
    long numberOfSamples;
    short sampleFlags;
    TimeValue sampleTime;
    if (!PyArg_ParseTuple(_args, "lllO&lh",
                          &dataOffset,
                          &size,
                          &durationPerSample,
                          ResObj_Convert, &sampleDescriptionH,
                          &numberOfSamples,
                          &sampleFlags))
        return NULL;
    _err = AddMediaSampleReference(_self->ob_itself,
                                   dataOffset,
                                   size,
                                   durationPerSample,
                                   sampleDescriptionH,
                                   numberOfSamples,
                                   sampleFlags,
                                   &sampleTime);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         sampleTime);
    return _res;
}

static PyObject *MediaObj_GetMediaSample(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataOut;
    long maxSizeToGrow;
    long size;
    TimeValue time;
    TimeValue sampleTime;
    TimeValue durationPerSample;
    SampleDescriptionHandle sampleDescriptionH;
    long sampleDescriptionIndex;
    long maxNumberOfSamples;
    long numberOfSamples;
    short sampleFlags;
    if (!PyArg_ParseTuple(_args, "O&llO&l",
                          ResObj_Convert, &dataOut,
                          &maxSizeToGrow,
                          &time,
                          ResObj_Convert, &sampleDescriptionH,
                          &maxNumberOfSamples))
        return NULL;
    _err = GetMediaSample(_self->ob_itself,
                          dataOut,
                          maxSizeToGrow,
                          &size,
                          time,
                          &sampleTime,
                          &durationPerSample,
                          sampleDescriptionH,
                          &sampleDescriptionIndex,
                          maxNumberOfSamples,
                          &numberOfSamples,
                          &sampleFlags);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("lllllh",
                         size,
                         sampleTime,
                         durationPerSample,
                         sampleDescriptionIndex,
                         numberOfSamples,
                         sampleFlags);
    return _res;
}

static PyObject *MediaObj_GetMediaSampleReference(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    long dataOffset;
    long size;
    TimeValue time;
    TimeValue sampleTime;
    TimeValue durationPerSample;
    SampleDescriptionHandle sampleDescriptionH;
    long sampleDescriptionIndex;
    long maxNumberOfSamples;
    long numberOfSamples;
    short sampleFlags;
    if (!PyArg_ParseTuple(_args, "lO&l",
                          &time,
                          ResObj_Convert, &sampleDescriptionH,
                          &maxNumberOfSamples))
        return NULL;
    _err = GetMediaSampleReference(_self->ob_itself,
                                   &dataOffset,
                                   &size,
                                   time,
                                   &sampleTime,
                                   &durationPerSample,
                                   sampleDescriptionH,
                                   &sampleDescriptionIndex,
                                   maxNumberOfSamples,
                                   &numberOfSamples,
                                   &sampleFlags);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("llllllh",
                         dataOffset,
                         size,
                         sampleTime,
                         durationPerSample,
                         sampleDescriptionIndex,
                         numberOfSamples,
                         sampleFlags);
    return _res;
}

static PyObject *MediaObj_SetMediaPreferredChunkSize(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    long maxChunkSize;
    if (!PyArg_ParseTuple(_args, "l",
                          &maxChunkSize))
        return NULL;
    _err = SetMediaPreferredChunkSize(_self->ob_itself,
                                      maxChunkSize);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaPreferredChunkSize(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    long maxChunkSize;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetMediaPreferredChunkSize(_self->ob_itself,
                                      &maxChunkSize);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         maxChunkSize);
    return _res;
}

static PyObject *MediaObj_SetMediaShadowSync(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    long frameDiffSampleNum;
    long syncSampleNum;
    if (!PyArg_ParseTuple(_args, "ll",
                          &frameDiffSampleNum,
                          &syncSampleNum))
        return NULL;
    _err = SetMediaShadowSync(_self->ob_itself,
                              frameDiffSampleNum,
                              syncSampleNum);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_GetMediaShadowSync(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    long frameDiffSampleNum;
    long syncSampleNum;
    if (!PyArg_ParseTuple(_args, "l",
                          &frameDiffSampleNum))
        return NULL;
    _err = GetMediaShadowSync(_self->ob_itself,
                              frameDiffSampleNum,
                              &syncSampleNum);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         syncSampleNum);
    return _res;
}

static PyObject *MediaObj_GetMediaDataSize(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long _rv;
    TimeValue startTime;
    TimeValue duration;
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    _rv = GetMediaDataSize(_self->ob_itself,
                           startTime,
                           duration);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MediaObj_GetMediaNextInterestingTime(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short interestingTimeFlags;
    TimeValue time;
    Fixed rate;
    TimeValue interestingTime;
    TimeValue interestingDuration;
    if (!PyArg_ParseTuple(_args, "hlO&",
                          &interestingTimeFlags,
                          &time,
                          PyMac_GetFixed, &rate))
        return NULL;
    GetMediaNextInterestingTime(_self->ob_itself,
                                interestingTimeFlags,
                                time,
                                rate,
                                &interestingTime,
                                &interestingDuration);
    _res = Py_BuildValue("ll",
                         interestingTime,
                         interestingDuration);
    return _res;
}

static PyObject *MediaObj_GetMediaDataRef(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    short index;
    Handle dataRef;
    OSType dataRefType;
    long dataRefAttributes;
    if (!PyArg_ParseTuple(_args, "h",
                          &index))
        return NULL;
    _err = GetMediaDataRef(_self->ob_itself,
                           index,
                           &dataRef,
                           &dataRefType,
                           &dataRefAttributes);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&O&l",
                         ResObj_New, dataRef,
                         PyMac_BuildOSType, dataRefType,
                         dataRefAttributes);
    return _res;
}

static PyObject *MediaObj_SetMediaDataRef(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    short index;
    Handle dataRef;
    OSType dataRefType;
    if (!PyArg_ParseTuple(_args, "hO&O&",
                          &index,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _err = SetMediaDataRef(_self->ob_itself,
                           index,
                           dataRef,
                           dataRefType);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_SetMediaDataRefAttributes(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    short index;
    long dataRefAttributes;
    if (!PyArg_ParseTuple(_args, "hl",
                          &index,
                          &dataRefAttributes))
        return NULL;
    _err = SetMediaDataRefAttributes(_self->ob_itself,
                                     index,
                                     dataRefAttributes);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MediaObj_AddMediaDataRef(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    short index;
    Handle dataRef;
    OSType dataRefType;
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _err = AddMediaDataRef(_self->ob_itself,
                           &index,
                           dataRef,
                           dataRefType);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         index);
    return _res;
}

static PyObject *MediaObj_GetMediaDataRefCount(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    short count;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetMediaDataRefCount(_self->ob_itself,
                                &count);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         count);
    return _res;
}

static PyObject *MediaObj_SetMediaPlayHints(_self, _args)
    MediaObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long flags;
    long flagsMask;
    if (!PyArg_ParseTuple(_args, "ll",
                          &flags,
                          &flagsMask))
        return NULL;
    SetMediaPlayHints(_self->ob_itself,
                      flags,
                      flagsMask);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyMethodDef MediaObj_methods[] = {
    {"LoadMediaIntoRam", (PyCFunction)MediaObj_LoadMediaIntoRam, 1,
     "(TimeValue time, TimeValue duration, long flags) -> None"},
    {"GetMediaTrack", (PyCFunction)MediaObj_GetMediaTrack, 1,
     "() -> (Track _rv)"},
    {"GetMediaTimeScale", (PyCFunction)MediaObj_GetMediaTimeScale, 1,
     "() -> (TimeScale _rv)"},
    {"SetMediaTimeScale", (PyCFunction)MediaObj_SetMediaTimeScale, 1,
     "(TimeScale timeScale) -> None"},
    {"GetMediaDuration", (PyCFunction)MediaObj_GetMediaDuration, 1,
     "() -> (TimeValue _rv)"},
    {"GetMediaLanguage", (PyCFunction)MediaObj_GetMediaLanguage, 1,
     "() -> (short _rv)"},
    {"SetMediaLanguage", (PyCFunction)MediaObj_SetMediaLanguage, 1,
     "(short language) -> None"},
    {"GetMediaQuality", (PyCFunction)MediaObj_GetMediaQuality, 1,
     "() -> (short _rv)"},
    {"SetMediaQuality", (PyCFunction)MediaObj_SetMediaQuality, 1,
     "(short quality) -> None"},
    {"GetMediaHandlerDescription", (PyCFunction)MediaObj_GetMediaHandlerDescription, 1,
     "(Str255 creatorName) -> (OSType mediaType, OSType creatorManufacturer)"},
    {"GetMediaUserData", (PyCFunction)MediaObj_GetMediaUserData, 1,
     "() -> (UserData _rv)"},
    {"GetMediaHandler", (PyCFunction)MediaObj_GetMediaHandler, 1,
     "() -> (MediaHandler _rv)"},
    {"SetMediaHandler", (PyCFunction)MediaObj_SetMediaHandler, 1,
     "(MediaHandlerComponent mH) -> None"},
    {"BeginMediaEdits", (PyCFunction)MediaObj_BeginMediaEdits, 1,
     "() -> None"},
    {"EndMediaEdits", (PyCFunction)MediaObj_EndMediaEdits, 1,
     "() -> None"},
    {"SetMediaDefaultDataRefIndex", (PyCFunction)MediaObj_SetMediaDefaultDataRefIndex, 1,
     "(short index) -> None"},
    {"GetMediaDataHandlerDescription", (PyCFunction)MediaObj_GetMediaDataHandlerDescription, 1,
     "(short index, Str255 creatorName) -> (OSType dhType, OSType creatorManufacturer)"},
    {"GetMediaDataHandler", (PyCFunction)MediaObj_GetMediaDataHandler, 1,
     "(short index) -> (DataHandler _rv)"},
    {"SetMediaDataHandler", (PyCFunction)MediaObj_SetMediaDataHandler, 1,
     "(short index, DataHandlerComponent dataHandler) -> None"},
    {"GetMediaSampleDescriptionCount", (PyCFunction)MediaObj_GetMediaSampleDescriptionCount, 1,
     "() -> (long _rv)"},
    {"GetMediaSampleDescription", (PyCFunction)MediaObj_GetMediaSampleDescription, 1,
     "(long index, SampleDescriptionHandle descH) -> None"},
    {"SetMediaSampleDescription", (PyCFunction)MediaObj_SetMediaSampleDescription, 1,
     "(long index, SampleDescriptionHandle descH) -> None"},
    {"GetMediaSampleCount", (PyCFunction)MediaObj_GetMediaSampleCount, 1,
     "() -> (long _rv)"},
    {"SampleNumToMediaTime", (PyCFunction)MediaObj_SampleNumToMediaTime, 1,
     "(long logicalSampleNum) -> (TimeValue sampleTime, TimeValue sampleDuration)"},
    {"MediaTimeToSampleNum", (PyCFunction)MediaObj_MediaTimeToSampleNum, 1,
     "(TimeValue time) -> (long sampleNum, TimeValue sampleTime, TimeValue sampleDuration)"},
    {"AddMediaSample", (PyCFunction)MediaObj_AddMediaSample, 1,
     "(Handle dataIn, long inOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)"},
    {"AddMediaSampleReference", (PyCFunction)MediaObj_AddMediaSampleReference, 1,
     "(long dataOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)"},
    {"GetMediaSample", (PyCFunction)MediaObj_GetMediaSample, 1,
     "(Handle dataOut, long maxSizeToGrow, TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)"},
    {"GetMediaSampleReference", (PyCFunction)MediaObj_GetMediaSampleReference, 1,
     "(TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long dataOffset, long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)"},
    {"SetMediaPreferredChunkSize", (PyCFunction)MediaObj_SetMediaPreferredChunkSize, 1,
     "(long maxChunkSize) -> None"},
    {"GetMediaPreferredChunkSize", (PyCFunction)MediaObj_GetMediaPreferredChunkSize, 1,
     "() -> (long maxChunkSize)"},
    {"SetMediaShadowSync", (PyCFunction)MediaObj_SetMediaShadowSync, 1,
     "(long frameDiffSampleNum, long syncSampleNum) -> None"},
    {"GetMediaShadowSync", (PyCFunction)MediaObj_GetMediaShadowSync, 1,
     "(long frameDiffSampleNum) -> (long syncSampleNum)"},
    {"GetMediaDataSize", (PyCFunction)MediaObj_GetMediaDataSize, 1,
     "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
    {"GetMediaNextInterestingTime", (PyCFunction)MediaObj_GetMediaNextInterestingTime, 1,
     "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
    {"GetMediaDataRef", (PyCFunction)MediaObj_GetMediaDataRef, 1,
     "(short index) -> (Handle dataRef, OSType dataRefType, long dataRefAttributes)"},
    {"SetMediaDataRef", (PyCFunction)MediaObj_SetMediaDataRef, 1,
     "(short index, Handle dataRef, OSType dataRefType) -> None"},
    {"SetMediaDataRefAttributes", (PyCFunction)MediaObj_SetMediaDataRefAttributes, 1,
     "(short index, long dataRefAttributes) -> None"},
    {"AddMediaDataRef", (PyCFunction)MediaObj_AddMediaDataRef, 1,
     "(Handle dataRef, OSType dataRefType) -> (short index)"},
    {"GetMediaDataRefCount", (PyCFunction)MediaObj_GetMediaDataRefCount, 1,
     "() -> (short count)"},
    {"SetMediaPlayHints", (PyCFunction)MediaObj_SetMediaPlayHints, 1,
     "(long flags, long flagsMask) -> None"},
    {NULL, NULL, 0}
};

PyMethodChain MediaObj_chain = { MediaObj_methods, NULL };

static PyObject *MediaObj_getattr(self, name)
    MediaObject *self;
    char *name;
{
    return Py_FindMethodInChain(&MediaObj_chain, (PyObject *)self, name);
}

#define MediaObj_setattr NULL

PyTypeObject Media_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0, /*ob_size*/
    "Media", /*tp_name*/
    sizeof(MediaObject), /*tp_basicsize*/
    0, /*tp_itemsize*/
    /* methods */
    (destructor) MediaObj_dealloc, /*tp_dealloc*/
    0, /*tp_print*/
    (getattrfunc) MediaObj_getattr, /*tp_getattr*/
    (setattrfunc) MediaObj_setattr, /*tp_setattr*/
};

/* --------------------- End object type Media ---------------------- */


/* ----------------------- Object type Track ------------------------ */

PyTypeObject Track_Type;

#define TrackObj_Check(x) ((x)->ob_type == &Track_Type)

typedef struct TrackObject {
    PyObject_HEAD
    Track ob_itself;
} TrackObject;

PyObject *TrackObj_New(itself)
    Track itself;
{
    TrackObject *it;
    if (itself == NULL) {
                        PyErr_SetString(Qt_Error,"Cannot create null Track");
                        return NULL;
                    }
    it = PyObject_NEW(TrackObject, &Track_Type);
    if (it == NULL) return NULL;
    it->ob_itself = itself;
    return (PyObject *)it;
}
TrackObj_Convert(v, p_itself)
    PyObject *v;
    Track *p_itself;
{
    if (!TrackObj_Check(v))
    {
        PyErr_SetString(PyExc_TypeError, "Track required");
        return 0;
    }
    *p_itself = ((TrackObject *)v)->ob_itself;
    return 1;
}

static void TrackObj_dealloc(self)
    TrackObject *self;
{
    DisposeMovieTrack(self->ob_itself);
    PyMem_DEL(self);
}

static PyObject *TrackObj_LoadTrackIntoRam(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue time;
    TimeValue duration;
    long flags;
    if (!PyArg_ParseTuple(_args, "lll",
                          &time,
                          &duration,
                          &flags))
        return NULL;
    _err = LoadTrackIntoRam(_self->ob_itself,
                            time,
                            duration,
                            flags);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackPict(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    PicHandle _rv;
    TimeValue time;
    if (!PyArg_ParseTuple(_args, "l",
                          &time))
        return NULL;
    _rv = GetTrackPict(_self->ob_itself,
                       time);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackClipRgn(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackClipRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_SetTrackClipRgn(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle theClip;
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &theClip))
        return NULL;
    SetTrackClipRgn(_self->ob_itself,
                    theClip);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackDisplayBoundsRgn(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackDisplayBoundsRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackMovieBoundsRgn(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackMovieBoundsRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackBoundsRgn(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackBoundsRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackMatte(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    PixMapHandle _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackMatte(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_SetTrackMatte(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    PixMapHandle theMatte;
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &theMatte))
        return NULL;
    SetTrackMatte(_self->ob_itself,
                  theMatte);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackID(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackID(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackMovie(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Movie _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackMovie(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackEnabled(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Boolean _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackEnabled(_self->ob_itself);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *TrackObj_SetTrackEnabled(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Boolean isEnabled;
    if (!PyArg_ParseTuple(_args, "b",
                          &isEnabled))
        return NULL;
    SetTrackEnabled(_self->ob_itself,
                    isEnabled);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackUsage(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackUsage(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *TrackObj_SetTrackUsage(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long usage;
    if (!PyArg_ParseTuple(_args, "l",
                          &usage))
        return NULL;
    SetTrackUsage(_self->ob_itself,
                  usage);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackDuration(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackDuration(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackOffset(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackOffset(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *TrackObj_SetTrackOffset(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue movieOffsetTime;
    if (!PyArg_ParseTuple(_args, "l",
                          &movieOffsetTime))
        return NULL;
    SetTrackOffset(_self->ob_itself,
                   movieOffsetTime);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackLayer(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackLayer(_self->ob_itself);
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *TrackObj_SetTrackLayer(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short layer;
    if (!PyArg_ParseTuple(_args, "h",
                          &layer))
        return NULL;
    SetTrackLayer(_self->ob_itself,
                  layer);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackAlternate(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Track _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackAlternate(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_SetTrackAlternate(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Track alternateT;
    if (!PyArg_ParseTuple(_args, "O&",
                          TrackObj_Convert, &alternateT))
        return NULL;
    SetTrackAlternate(_self->ob_itself,
                      alternateT);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackVolume(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackVolume(_self->ob_itself);
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *TrackObj_SetTrackVolume(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short volume;
    if (!PyArg_ParseTuple(_args, "h",
                          &volume))
        return NULL;
    SetTrackVolume(_self->ob_itself,
                   volume);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackDimensions(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Fixed width;
    Fixed height;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetTrackDimensions(_self->ob_itself,
                       &width,
                       &height);
    _res = Py_BuildValue("O&O&",
                         PyMac_BuildFixed, width,
                         PyMac_BuildFixed, height);
    return _res;
}

static PyObject *TrackObj_SetTrackDimensions(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Fixed width;
    Fixed height;
    if (!PyArg_ParseTuple(_args, "O&O&",
                          PyMac_GetFixed, &width,
                          PyMac_GetFixed, &height))
        return NULL;
    SetTrackDimensions(_self->ob_itself,
                       width,
                       height);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackUserData(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    UserData _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackUserData(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         UserDataObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_NewTrackMedia(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Media _rv;
    OSType mediaType;
    TimeScale timeScale;
    Handle dataRef;
    OSType dataRefType;
    if (!PyArg_ParseTuple(_args, "O&lO&O&",
                          PyMac_GetOSType, &mediaType,
                          &timeScale,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _rv = NewTrackMedia(_self->ob_itself,
                        mediaType,
                        timeScale,
                        dataRef,
                        dataRefType);
    _res = Py_BuildValue("O&",
                         MediaObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackMedia(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Media _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackMedia(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         MediaObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_InsertMediaIntoTrack(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue trackStart;
    TimeValue mediaTime;
    TimeValue mediaDuration;
    Fixed mediaRate;
    if (!PyArg_ParseTuple(_args, "lllO&",
                          &trackStart,
                          &mediaTime,
                          &mediaDuration,
                          PyMac_GetFixed, &mediaRate))
        return NULL;
    _err = InsertMediaIntoTrack(_self->ob_itself,
                                trackStart,
                                mediaTime,
                                mediaDuration,
                                mediaRate);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_InsertTrackSegment(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Track dstTrack;
    TimeValue srcIn;
    TimeValue srcDuration;
    TimeValue dstIn;
    if (!PyArg_ParseTuple(_args, "O&lll",
                          TrackObj_Convert, &dstTrack,
                          &srcIn,
                          &srcDuration,
                          &dstIn))
        return NULL;
    _err = InsertTrackSegment(_self->ob_itself,
                              dstTrack,
                              srcIn,
                              srcDuration,
                              dstIn);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_InsertEmptyTrackSegment(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue dstIn;
    TimeValue dstDuration;
    if (!PyArg_ParseTuple(_args, "ll",
                          &dstIn,
                          &dstDuration))
        return NULL;
    _err = InsertEmptyTrackSegment(_self->ob_itself,
                                   dstIn,
                                   dstDuration);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_DeleteTrackSegment(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue startTime;
    TimeValue duration;
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    _err = DeleteTrackSegment(_self->ob_itself,
                              startTime,
                              duration);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_ScaleTrackSegment(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue startTime;
    TimeValue oldDuration;
    TimeValue newDuration;
    if (!PyArg_ParseTuple(_args, "lll",
                          &startTime,
                          &oldDuration,
                          &newDuration))
        return NULL;
    _err = ScaleTrackSegment(_self->ob_itself,
                             startTime,
                             oldDuration,
                             newDuration);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_IsScrapMovie(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Component _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = IsScrapMovie(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         CmpObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_CopyTrackSettings(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Track dstTrack;
    if (!PyArg_ParseTuple(_args, "O&",
                          TrackObj_Convert, &dstTrack))
        return NULL;
    _err = CopyTrackSettings(_self->ob_itself,
                             dstTrack);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_AddEmptyTrackToMovie(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie dstMovie;
    Handle dataRef;
    OSType dataRefType;
    Track dstTrack;
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          MovieObj_Convert, &dstMovie,
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _err = AddEmptyTrackToMovie(_self->ob_itself,
                                dstMovie,
                                dataRef,
                                dataRefType,
                                &dstTrack);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         TrackObj_New, dstTrack);
    return _res;
}

static PyObject *TrackObj_AddTrackReference(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Track refTrack;
    OSType refType;
    long addedIndex;
    if (!PyArg_ParseTuple(_args, "O&O&",
                          TrackObj_Convert, &refTrack,
                          PyMac_GetOSType, &refType))
        return NULL;
    _err = AddTrackReference(_self->ob_itself,
                             refTrack,
                             refType,
                             &addedIndex);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         addedIndex);
    return _res;
}

static PyObject *TrackObj_DeleteTrackReference(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    OSType refType;
    long index;
    if (!PyArg_ParseTuple(_args, "O&l",
                          PyMac_GetOSType, &refType,
                          &index))
        return NULL;
    _err = DeleteTrackReference(_self->ob_itself,
                                refType,
                                index);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_SetTrackReference(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Track refTrack;
    OSType refType;
    long index;
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          TrackObj_Convert, &refTrack,
                          PyMac_GetOSType, &refType,
                          &index))
        return NULL;
    _err = SetTrackReference(_self->ob_itself,
                             refTrack,
                             refType,
                             index);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackReference(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Track _rv;
    OSType refType;
    long index;
    if (!PyArg_ParseTuple(_args, "O&l",
                          PyMac_GetOSType, &refType,
                          &index))
        return NULL;
    _rv = GetTrackReference(_self->ob_itself,
                            refType,
                            index);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetNextTrackReferenceType(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSType _rv;
    OSType refType;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetOSType, &refType))
        return NULL;
    _rv = GetNextTrackReferenceType(_self->ob_itself,
                                    refType);
    _res = Py_BuildValue("O&",
                         PyMac_BuildOSType, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackReferenceCount(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long _rv;
    OSType refType;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetOSType, &refType))
        return NULL;
    _rv = GetTrackReferenceCount(_self->ob_itself,
                                 refType);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackEditRate(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Fixed _rv;
    TimeValue atTime;
    if (!PyArg_ParseTuple(_args, "l",
                          &atTime))
        return NULL;
    _rv = GetTrackEditRate(_self->ob_itself,
                           atTime);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackDataSize(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long _rv;
    TimeValue startTime;
    TimeValue duration;
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    _rv = GetTrackDataSize(_self->ob_itself,
                           startTime,
                           duration);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *TrackObj_PtInTrack(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Boolean _rv;
    Point pt;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetPoint, &pt))
        return NULL;
    _rv = PtInTrack(_self->ob_itself,
                    pt);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackNextInterestingTime(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short interestingTimeFlags;
    TimeValue time;
    Fixed rate;
    TimeValue interestingTime;
    TimeValue interestingDuration;
    if (!PyArg_ParseTuple(_args, "hlO&",
                          &interestingTimeFlags,
                          &time,
                          PyMac_GetFixed, &rate))
        return NULL;
    GetTrackNextInterestingTime(_self->ob_itself,
                                interestingTimeFlags,
                                time,
                                rate,
                                &interestingTime,
                                &interestingDuration);
    _res = Py_BuildValue("ll",
                         interestingTime,
                         interestingDuration);
    return _res;
}

static PyObject *TrackObj_GetTrackSegmentDisplayBoundsRgn(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    TimeValue time;
    TimeValue duration;
    if (!PyArg_ParseTuple(_args, "ll",
                          &time,
                          &duration))
        return NULL;
    _rv = GetTrackSegmentDisplayBoundsRgn(_self->ob_itself,
                                          time,
                                          duration);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *TrackObj_GetTrackStatus(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetTrackStatus(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *TrackObj_SetTrackLoadSettings(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue preloadTime;
    TimeValue preloadDuration;
    long preloadFlags;
    long defaultHints;
    if (!PyArg_ParseTuple(_args, "llll",
                          &preloadTime,
                          &preloadDuration,
                          &preloadFlags,
                          &defaultHints))
        return NULL;
    SetTrackLoadSettings(_self->ob_itself,
                         preloadTime,
                         preloadDuration,
                         preloadFlags,
                         defaultHints);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *TrackObj_GetTrackLoadSettings(_self, _args)
    TrackObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue preloadTime;
    TimeValue preloadDuration;
    long preloadFlags;
    long defaultHints;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetTrackLoadSettings(_self->ob_itself,
                         &preloadTime,
                         &preloadDuration,
                         &preloadFlags,
                         &defaultHints);
    _res = Py_BuildValue("llll",
                         preloadTime,
                         preloadDuration,
                         preloadFlags,
                         defaultHints);
    return _res;
}

static PyMethodDef TrackObj_methods[] = {
    {"LoadTrackIntoRam", (PyCFunction)TrackObj_LoadTrackIntoRam, 1,
     "(TimeValue time, TimeValue duration, long flags) -> None"},
    {"GetTrackPict", (PyCFunction)TrackObj_GetTrackPict, 1,
     "(TimeValue time) -> (PicHandle _rv)"},
    {"GetTrackClipRgn", (PyCFunction)TrackObj_GetTrackClipRgn, 1,
     "() -> (RgnHandle _rv)"},
    {"SetTrackClipRgn", (PyCFunction)TrackObj_SetTrackClipRgn, 1,
     "(RgnHandle theClip) -> None"},
    {"GetTrackDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackDisplayBoundsRgn, 1,
     "() -> (RgnHandle _rv)"},
    {"GetTrackMovieBoundsRgn", (PyCFunction)TrackObj_GetTrackMovieBoundsRgn, 1,
     "() -> (RgnHandle _rv)"},
    {"GetTrackBoundsRgn", (PyCFunction)TrackObj_GetTrackBoundsRgn, 1,
     "() -> (RgnHandle _rv)"},
    {"GetTrackMatte", (PyCFunction)TrackObj_GetTrackMatte, 1,
     "() -> (PixMapHandle _rv)"},
    {"SetTrackMatte", (PyCFunction)TrackObj_SetTrackMatte, 1,
     "(PixMapHandle theMatte) -> None"},
    {"GetTrackID", (PyCFunction)TrackObj_GetTrackID, 1,
     "() -> (long _rv)"},
    {"GetTrackMovie", (PyCFunction)TrackObj_GetTrackMovie, 1,
     "() -> (Movie _rv)"},
    {"GetTrackEnabled", (PyCFunction)TrackObj_GetTrackEnabled, 1,
     "() -> (Boolean _rv)"},
    {"SetTrackEnabled", (PyCFunction)TrackObj_SetTrackEnabled, 1,
     "(Boolean isEnabled) -> None"},
    {"GetTrackUsage", (PyCFunction)TrackObj_GetTrackUsage, 1,
     "() -> (long _rv)"},
    {"SetTrackUsage", (PyCFunction)TrackObj_SetTrackUsage, 1,
     "(long usage) -> None"},
    {"GetTrackDuration", (PyCFunction)TrackObj_GetTrackDuration, 1,
     "() -> (TimeValue _rv)"},
    {"GetTrackOffset", (PyCFunction)TrackObj_GetTrackOffset, 1,
     "() -> (TimeValue _rv)"},
    {"SetTrackOffset", (PyCFunction)TrackObj_SetTrackOffset, 1,
     "(TimeValue movieOffsetTime) -> None"},
    {"GetTrackLayer", (PyCFunction)TrackObj_GetTrackLayer, 1,
     "() -> (short _rv)"},
    {"SetTrackLayer", (PyCFunction)TrackObj_SetTrackLayer, 1,
     "(short layer) -> None"},
    {"GetTrackAlternate", (PyCFunction)TrackObj_GetTrackAlternate, 1,
     "() -> (Track _rv)"},
    {"SetTrackAlternate", (PyCFunction)TrackObj_SetTrackAlternate, 1,
     "(Track alternateT) -> None"},
    {"GetTrackVolume", (PyCFunction)TrackObj_GetTrackVolume, 1,
     "() -> (short _rv)"},
    {"SetTrackVolume", (PyCFunction)TrackObj_SetTrackVolume, 1,
     "(short volume) -> None"},
    {"GetTrackDimensions", (PyCFunction)TrackObj_GetTrackDimensions, 1,
     "() -> (Fixed width, Fixed height)"},
    {"SetTrackDimensions", (PyCFunction)TrackObj_SetTrackDimensions, 1,
     "(Fixed width, Fixed height) -> None"},
    {"GetTrackUserData", (PyCFunction)TrackObj_GetTrackUserData, 1,
     "() -> (UserData _rv)"},
    {"NewTrackMedia", (PyCFunction)TrackObj_NewTrackMedia, 1,
     "(OSType mediaType, TimeScale timeScale, Handle dataRef, OSType dataRefType) -> (Media _rv)"},
    {"GetTrackMedia", (PyCFunction)TrackObj_GetTrackMedia, 1,
     "() -> (Media _rv)"},
    {"InsertMediaIntoTrack", (PyCFunction)TrackObj_InsertMediaIntoTrack, 1,
     "(TimeValue trackStart, TimeValue mediaTime, TimeValue mediaDuration, Fixed mediaRate) -> None"},
    {"InsertTrackSegment", (PyCFunction)TrackObj_InsertTrackSegment, 1,
     "(Track dstTrack, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None"},
    {"InsertEmptyTrackSegment", (PyCFunction)TrackObj_InsertEmptyTrackSegment, 1,
     "(TimeValue dstIn, TimeValue dstDuration) -> None"},
    {"DeleteTrackSegment", (PyCFunction)TrackObj_DeleteTrackSegment, 1,
     "(TimeValue startTime, TimeValue duration) -> None"},
    {"ScaleTrackSegment", (PyCFunction)TrackObj_ScaleTrackSegment, 1,
     "(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None"},
    {"IsScrapMovie", (PyCFunction)TrackObj_IsScrapMovie, 1,
     "() -> (Component _rv)"},
    {"CopyTrackSettings", (PyCFunction)TrackObj_CopyTrackSettings, 1,
     "(Track dstTrack) -> None"},
    {"AddEmptyTrackToMovie", (PyCFunction)TrackObj_AddEmptyTrackToMovie, 1,
     "(Movie dstMovie, Handle dataRef, OSType dataRefType) -> (Track dstTrack)"},
    {"AddTrackReference", (PyCFunction)TrackObj_AddTrackReference, 1,
     "(Track refTrack, OSType refType) -> (long addedIndex)"},
    {"DeleteTrackReference", (PyCFunction)TrackObj_DeleteTrackReference, 1,
     "(OSType refType, long index) -> None"},
    {"SetTrackReference", (PyCFunction)TrackObj_SetTrackReference, 1,
     "(Track refTrack, OSType refType, long index) -> None"},
    {"GetTrackReference", (PyCFunction)TrackObj_GetTrackReference, 1,
     "(OSType refType, long index) -> (Track _rv)"},
    {"GetNextTrackReferenceType", (PyCFunction)TrackObj_GetNextTrackReferenceType, 1,
     "(OSType refType) -> (OSType _rv)"},
    {"GetTrackReferenceCount", (PyCFunction)TrackObj_GetTrackReferenceCount, 1,
     "(OSType refType) -> (long _rv)"},
    {"GetTrackEditRate", (PyCFunction)TrackObj_GetTrackEditRate, 1,
     "(TimeValue atTime) -> (Fixed _rv)"},
    {"GetTrackDataSize", (PyCFunction)TrackObj_GetTrackDataSize, 1,
     "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
    {"PtInTrack", (PyCFunction)TrackObj_PtInTrack, 1,
     "(Point pt) -> (Boolean _rv)"},
    {"GetTrackNextInterestingTime", (PyCFunction)TrackObj_GetTrackNextInterestingTime, 1,
     "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
    {"GetTrackSegmentDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackSegmentDisplayBoundsRgn, 1,
     "(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"},
    {"GetTrackStatus", (PyCFunction)TrackObj_GetTrackStatus, 1,
     "() -> (ComponentResult _rv)"},
    {"SetTrackLoadSettings", (PyCFunction)TrackObj_SetTrackLoadSettings, 1,
     "(TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints) -> None"},
    {"GetTrackLoadSettings", (PyCFunction)TrackObj_GetTrackLoadSettings, 1,
     "() -> (TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints)"},
    {NULL, NULL, 0}
};

PyMethodChain TrackObj_chain = { TrackObj_methods, NULL };

static PyObject *TrackObj_getattr(self, name)
    TrackObject *self;
    char *name;
{
    return Py_FindMethodInChain(&TrackObj_chain, (PyObject *)self, name);
}

#define TrackObj_setattr NULL

PyTypeObject Track_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0, /*ob_size*/
    "Track", /*tp_name*/
    sizeof(TrackObject), /*tp_basicsize*/
    0, /*tp_itemsize*/
    /* methods */
    (destructor) TrackObj_dealloc, /*tp_dealloc*/
    0, /*tp_print*/
    (getattrfunc) TrackObj_getattr, /*tp_getattr*/
    (setattrfunc) TrackObj_setattr, /*tp_setattr*/
};

/* --------------------- End object type Track ---------------------- */


/* ----------------------- Object type Movie ------------------------ */

PyTypeObject Movie_Type;

#define MovieObj_Check(x) ((x)->ob_type == &Movie_Type)

typedef struct MovieObject {
    PyObject_HEAD
    Movie ob_itself;
} MovieObject;

PyObject *MovieObj_New(itself)
    Movie itself;
{
    MovieObject *it;
    if (itself == NULL) {
                        PyErr_SetString(Qt_Error,"Cannot create null Movie");
                        return NULL;
                    }
    it = PyObject_NEW(MovieObject, &Movie_Type);
    if (it == NULL) return NULL;
    it->ob_itself = itself;
    return (PyObject *)it;
}
MovieObj_Convert(v, p_itself)
    PyObject *v;
    Movie *p_itself;
{
    if (!MovieObj_Check(v))
    {
        PyErr_SetString(PyExc_TypeError, "Movie required");
        return 0;
    }
    *p_itself = ((MovieObject *)v)->ob_itself;
    return 1;
}

static void MovieObj_dealloc(self)
    MovieObject *self;
{
    DisposeMovie(self->ob_itself);
    PyMem_DEL(self);
}

static PyObject *MovieObj_MoviesTask(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long maxMilliSecToUse;
    if (!PyArg_ParseTuple(_args, "l",
                          &maxMilliSecToUse))
        return NULL;
    MoviesTask(_self->ob_itself,
               maxMilliSecToUse);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_PrerollMovie(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue time;
    Fixed Rate;
    if (!PyArg_ParseTuple(_args, "lO&",
                          &time,
                          PyMac_GetFixed, &Rate))
        return NULL;
    _err = PrerollMovie(_self->ob_itself,
                        time,
                        Rate);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_LoadMovieIntoRam(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue time;
    TimeValue duration;
    long flags;
    if (!PyArg_ParseTuple(_args, "lll",
                          &time,
                          &duration,
                          &flags))
        return NULL;
    _err = LoadMovieIntoRam(_self->ob_itself,
                            time,
                            duration,
                            flags);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_SetMovieActive(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Boolean active;
    if (!PyArg_ParseTuple(_args, "b",
                          &active))
        return NULL;
    SetMovieActive(_self->ob_itself,
                   active);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieActive(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Boolean _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieActive(_self->ob_itself);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *MovieObj_StartMovie(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    StartMovie(_self->ob_itself);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_StopMovie(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    StopMovie(_self->ob_itself);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GoToBeginningOfMovie(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GoToBeginningOfMovie(_self->ob_itself);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GoToEndOfMovie(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GoToEndOfMovie(_self->ob_itself);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_IsMovieDone(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Boolean _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = IsMovieDone(_self->ob_itself);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *MovieObj_GetMoviePreviewMode(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Boolean _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMoviePreviewMode(_self->ob_itself);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *MovieObj_SetMoviePreviewMode(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Boolean usePreview;
    if (!PyArg_ParseTuple(_args, "b",
                          &usePreview))
        return NULL;
    SetMoviePreviewMode(_self->ob_itself,
                        usePreview);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_ShowMoviePoster(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    ShowMoviePoster(_self->ob_itself);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieTimeBase(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeBase _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieTimeBase(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         TimeBaseObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetNextTrackForCompositing(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Track _rv;
    Track theTrack;
    if (!PyArg_ParseTuple(_args, "O&",
                          TrackObj_Convert, &theTrack))
        return NULL;
    _rv = GetNextTrackForCompositing(_self->ob_itself,
                                     theTrack);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetPrevTrackForCompositing(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Track _rv;
    Track theTrack;
    if (!PyArg_ParseTuple(_args, "O&",
                          TrackObj_Convert, &theTrack))
        return NULL;
    _rv = GetPrevTrackForCompositing(_self->ob_itself,
                                     theTrack);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetMoviePict(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    PicHandle _rv;
    TimeValue time;
    if (!PyArg_ParseTuple(_args, "l",
                          &time))
        return NULL;
    _rv = GetMoviePict(_self->ob_itself,
                       time);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetMoviePosterPict(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    PicHandle _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMoviePosterPict(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_UpdateMovie(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = UpdateMovie(_self->ob_itself);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieBox(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Rect boxRect;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetMovieBox(_self->ob_itself,
                &boxRect);
    _res = Py_BuildValue("O&",
                         PyMac_BuildRect, &boxRect);
    return _res;
}

static PyObject *MovieObj_SetMovieBox(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Rect boxRect;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetRect, &boxRect))
        return NULL;
    SetMovieBox(_self->ob_itself,
                &boxRect);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieDisplayClipRgn(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieDisplayClipRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_SetMovieDisplayClipRgn(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle theClip;
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &theClip))
        return NULL;
    SetMovieDisplayClipRgn(_self->ob_itself,
                           theClip);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieClipRgn(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieClipRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_SetMovieClipRgn(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle theClip;
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &theClip))
        return NULL;
    SetMovieClipRgn(_self->ob_itself,
                    theClip);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieDisplayBoundsRgn(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieDisplayBoundsRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetMovieBoundsRgn(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieBoundsRgn(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_PutMovieIntoHandle(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle publicMovie;
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &publicMovie))
        return NULL;
    _err = PutMovieIntoHandle(_self->ob_itself,
                              publicMovie);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_PutMovieIntoDataFork(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    short fRefNum;
    long offset;
    long maxSize;
    if (!PyArg_ParseTuple(_args, "hll",
                          &fRefNum,
                          &offset,
                          &maxSize))
        return NULL;
    _err = PutMovieIntoDataFork(_self->ob_itself,
                                fRefNum,
                                offset,
                                maxSize);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieTimeScale(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeScale _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieTimeScale(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieObj_SetMovieTimeScale(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeScale timeScale;
    if (!PyArg_ParseTuple(_args, "l",
                          &timeScale))
        return NULL;
    SetMovieTimeScale(_self->ob_itself,
                      timeScale);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieDuration(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieDuration(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieObj_GetMovieRate(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Fixed _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieRate(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *MovieObj_SetMovieRate(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Fixed rate;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetFixed, &rate))
        return NULL;
    SetMovieRate(_self->ob_itself,
                 rate);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMoviePreferredRate(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Fixed _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMoviePreferredRate(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         PyMac_BuildFixed, _rv);
    return _res;
}

static PyObject *MovieObj_SetMoviePreferredRate(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Fixed rate;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetFixed, &rate))
        return NULL;
    SetMoviePreferredRate(_self->ob_itself,
                          rate);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMoviePreferredVolume(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMoviePreferredVolume(_self->ob_itself);
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *MovieObj_SetMoviePreferredVolume(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short volume;
    if (!PyArg_ParseTuple(_args, "h",
                          &volume))
        return NULL;
    SetMoviePreferredVolume(_self->ob_itself,
                            volume);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieVolume(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieVolume(_self->ob_itself);
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *MovieObj_SetMovieVolume(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short volume;
    if (!PyArg_ParseTuple(_args, "h",
                          &volume))
        return NULL;
    SetMovieVolume(_self->ob_itself,
                   volume);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMoviePreviewTime(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue previewTime;
    TimeValue previewDuration;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetMoviePreviewTime(_self->ob_itself,
                        &previewTime,
                        &previewDuration);
    _res = Py_BuildValue("ll",
                         previewTime,
                         previewDuration);
    return _res;
}

static PyObject *MovieObj_SetMoviePreviewTime(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue previewTime;
    TimeValue previewDuration;
    if (!PyArg_ParseTuple(_args, "ll",
                          &previewTime,
                          &previewDuration))
        return NULL;
    SetMoviePreviewTime(_self->ob_itself,
                        previewTime,
                        previewDuration);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMoviePosterTime(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMoviePosterTime(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieObj_SetMoviePosterTime(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue posterTime;
    if (!PyArg_ParseTuple(_args, "l",
                          &posterTime))
        return NULL;
    SetMoviePosterTime(_self->ob_itself,
                       posterTime);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieSelection(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue selectionTime;
    TimeValue selectionDuration;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetMovieSelection(_self->ob_itself,
                      &selectionTime,
                      &selectionDuration);
    _res = Py_BuildValue("ll",
                         selectionTime,
                         selectionDuration);
    return _res;
}

static PyObject *MovieObj_SetMovieSelection(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue selectionTime;
    TimeValue selectionDuration;
    if (!PyArg_ParseTuple(_args, "ll",
                          &selectionTime,
                          &selectionDuration))
        return NULL;
    SetMovieSelection(_self->ob_itself,
                      selectionTime,
                      selectionDuration);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_SetMovieActiveSegment(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue startTime;
    TimeValue duration;
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    SetMovieActiveSegment(_self->ob_itself,
                          startTime,
                          duration);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieActiveSegment(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue startTime;
    TimeValue duration;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetMovieActiveSegment(_self->ob_itself,
                          &startTime,
                          &duration);
    _res = Py_BuildValue("ll",
                         startTime,
                         duration);
    return _res;
}

static PyObject *MovieObj_SetMovieTimeValue(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue newtime;
    if (!PyArg_ParseTuple(_args, "l",
                          &newtime))
        return NULL;
    SetMovieTimeValue(_self->ob_itself,
                      newtime);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieUserData(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    UserData _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieUserData(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         UserDataObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetMovieTrackCount(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieTrackCount(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieObj_GetMovieTrack(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Track _rv;
    long trackID;
    if (!PyArg_ParseTuple(_args, "l",
                          &trackID))
        return NULL;
    _rv = GetMovieTrack(_self->ob_itself,
                        trackID);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetMovieIndTrack(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Track _rv;
    long index;
    if (!PyArg_ParseTuple(_args, "l",
                          &index))
        return NULL;
    _rv = GetMovieIndTrack(_self->ob_itself,
                           index);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetMovieIndTrackType(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Track _rv;
    long index;
    OSType trackType;
    long flags;
    if (!PyArg_ParseTuple(_args, "lO&l",
                          &index,
                          PyMac_GetOSType, &trackType,
                          &flags))
        return NULL;
    _rv = GetMovieIndTrackType(_self->ob_itself,
                               index,
                               trackType,
                               flags);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_NewMovieTrack(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Track _rv;
    Fixed width;
    Fixed height;
    short trackVolume;
    if (!PyArg_ParseTuple(_args, "O&O&h",
                          PyMac_GetFixed, &width,
                          PyMac_GetFixed, &height,
                          &trackVolume))
        return NULL;
    _rv = NewMovieTrack(_self->ob_itself,
                        width,
                        height,
                        trackVolume);
    _res = Py_BuildValue("O&",
                         TrackObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_SetAutoTrackAlternatesEnabled(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Boolean enable;
    if (!PyArg_ParseTuple(_args, "b",
                          &enable))
        return NULL;
    SetAutoTrackAlternatesEnabled(_self->ob_itself,
                                  enable);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_SelectMovieAlternates(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    SelectMovieAlternates(_self->ob_itself);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_InsertMovieSegment(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie dstMovie;
    TimeValue srcIn;
    TimeValue srcDuration;
    TimeValue dstIn;
    if (!PyArg_ParseTuple(_args, "O&lll",
                          MovieObj_Convert, &dstMovie,
                          &srcIn,
                          &srcDuration,
                          &dstIn))
        return NULL;
    _err = InsertMovieSegment(_self->ob_itself,
                              dstMovie,
                              srcIn,
                              srcDuration,
                              dstIn);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_InsertEmptyMovieSegment(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue dstIn;
    TimeValue dstDuration;
    if (!PyArg_ParseTuple(_args, "ll",
                          &dstIn,
                          &dstDuration))
        return NULL;
    _err = InsertEmptyMovieSegment(_self->ob_itself,
                                   dstIn,
                                   dstDuration);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_DeleteMovieSegment(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue startTime;
    TimeValue duration;
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    _err = DeleteMovieSegment(_self->ob_itself,
                              startTime,
                              duration);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_ScaleMovieSegment(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    TimeValue startTime;
    TimeValue oldDuration;
    TimeValue newDuration;
    if (!PyArg_ParseTuple(_args, "lll",
                          &startTime,
                          &oldDuration,
                          &newDuration))
        return NULL;
    _err = ScaleMovieSegment(_self->ob_itself,
                             startTime,
                             oldDuration,
                             newDuration);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_CutMovieSelection(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Movie _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = CutMovieSelection(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_CopyMovieSelection(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Movie _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = CopyMovieSelection(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_PasteMovieSelection(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Movie src;
    if (!PyArg_ParseTuple(_args, "O&",
                          MovieObj_Convert, &src))
        return NULL;
    PasteMovieSelection(_self->ob_itself,
                        src);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_AddMovieSelection(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Movie src;
    if (!PyArg_ParseTuple(_args, "O&",
                          MovieObj_Convert, &src))
        return NULL;
    AddMovieSelection(_self->ob_itself,
                      src);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_ClearMovieSelection(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    ClearMovieSelection(_self->ob_itself);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_PutMovieIntoTypedHandle(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Track targetTrack;
    OSType handleType;
    Handle publicMovie;
    TimeValue start;
    TimeValue dur;
    long flags;
    ComponentInstance userComp;
    if (!PyArg_ParseTuple(_args, "O&O&O&lllO&",
                          TrackObj_Convert, &targetTrack,
                          PyMac_GetOSType, &handleType,
                          ResObj_Convert, &publicMovie,
                          &start,
                          &dur,
                          &flags,
                          CmpInstObj_Convert, &userComp))
        return NULL;
    _err = PutMovieIntoTypedHandle(_self->ob_itself,
                                   targetTrack,
                                   handleType,
                                   publicMovie,
                                   start,
                                   dur,
                                   flags,
                                   userComp);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_CopyMovieSettings(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie dstMovie;
    if (!PyArg_ParseTuple(_args, "O&",
                          MovieObj_Convert, &dstMovie))
        return NULL;
    _err = CopyMovieSettings(_self->ob_itself,
                             dstMovie);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_ConvertMovieToFile(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Track onlyTrack;
    FSSpec outputFile;
    OSType fileType;
    OSType creator;
    ScriptCode scriptTag;
    short resID;
    long flags;
    ComponentInstance userComp;
    if (!PyArg_ParseTuple(_args, "O&O&O&O&hlO&",
                          TrackObj_Convert, &onlyTrack,
                          PyMac_GetFSSpec, &outputFile,
                          PyMac_GetOSType, &fileType,
                          PyMac_GetOSType, &creator,
                          &scriptTag,
                          &flags,
                          CmpInstObj_Convert, &userComp))
        return NULL;
    _err = ConvertMovieToFile(_self->ob_itself,
                              onlyTrack,
                              &outputFile,
                              fileType,
                              creator,
                              scriptTag,
                              &resID,
                              flags,
                              userComp);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         resID);
    return _res;
}

static PyObject *MovieObj_GetMovieDataSize(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long _rv;
    TimeValue startTime;
    TimeValue duration;
    if (!PyArg_ParseTuple(_args, "ll",
                          &startTime,
                          &duration))
        return NULL;
    _rv = GetMovieDataSize(_self->ob_itself,
                           startTime,
                           duration);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MovieObj_PtInMovie(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Boolean _rv;
    Point pt;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetPoint, &pt))
        return NULL;
    _rv = PtInMovie(_self->ob_itself,
                    pt);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *MovieObj_SetMovieLanguage(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long language;
    if (!PyArg_ParseTuple(_args, "l",
                          &language))
        return NULL;
    SetMovieLanguage(_self->ob_itself,
                     language);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieNextInterestingTime(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    short interestingTimeFlags;
    short numMediaTypes;
    OSType whichMediaTypes;
    TimeValue time;
    Fixed rate;
    TimeValue interestingTime;
    TimeValue interestingDuration;
    if (!PyArg_ParseTuple(_args, "hhO&lO&",
                          &interestingTimeFlags,
                          &numMediaTypes,
                          PyMac_GetOSType, &whichMediaTypes,
                          &time,
                          PyMac_GetFixed, &rate))
        return NULL;
    GetMovieNextInterestingTime(_self->ob_itself,
                                interestingTimeFlags,
                                numMediaTypes,
                                &whichMediaTypes,
                                time,
                                rate,
                                &interestingTime,
                                &interestingDuration);
    _res = Py_BuildValue("ll",
                         interestingTime,
                         interestingDuration);
    return _res;
}

static PyObject *MovieObj_AddMovieResource(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    short resRefNum;
    short resId;
    Str255 resName;
    if (!PyArg_ParseTuple(_args, "hO&",
                          &resRefNum,
                          PyMac_GetStr255, resName))
        return NULL;
    _err = AddMovieResource(_self->ob_itself,
                            resRefNum,
                            &resId,
                            resName);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         resId);
    return _res;
}

static PyObject *MovieObj_UpdateMovieResource(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    short resRefNum;
    short resId;
    Str255 resName;
    if (!PyArg_ParseTuple(_args, "hhO&",
                          &resRefNum,
                          &resId,
                          PyMac_GetStr255, resName))
        return NULL;
    _err = UpdateMovieResource(_self->ob_itself,
                               resRefNum,
                               resId,
                               resName);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_HasMovieChanged(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Boolean _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = HasMovieChanged(_self->ob_itself);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *MovieObj_ClearMovieChanged(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    ClearMovieChanged(_self->ob_itself);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_SetMovieDefaultDataRef(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataRef;
    OSType dataRefType;
    if (!PyArg_ParseTuple(_args, "O&O&",
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataRefType))
        return NULL;
    _err = SetMovieDefaultDataRef(_self->ob_itself,
                                  dataRef,
                                  dataRefType);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieDefaultDataRef(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle dataRef;
    OSType dataRefType;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetMovieDefaultDataRef(_self->ob_itself,
                                  &dataRef,
                                  &dataRefType);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&O&",
                         ResObj_New, dataRef,
                         PyMac_BuildOSType, dataRefType);
    return _res;
}

static PyObject *MovieObj_SetMovieColorTable(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    CTabHandle ctab;
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &ctab))
        return NULL;
    _err = SetMovieColorTable(_self->ob_itself,
                              ctab);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieColorTable(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    CTabHandle ctab;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetMovieColorTable(_self->ob_itself,
                              &ctab);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         ResObj_New, ctab);
    return _res;
}

static PyObject *MovieObj_FlattenMovie(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long movieFlattenFlags;
    FSSpec theFile;
    OSType creator;
    ScriptCode scriptTag;
    long createMovieFileFlags;
    short resId;
    Str255 resName;
    if (!PyArg_ParseTuple(_args, "lO&O&hlO&",
                          &movieFlattenFlags,
                          PyMac_GetFSSpec, &theFile,
                          PyMac_GetOSType, &creator,
                          &scriptTag,
                          &createMovieFileFlags,
                          PyMac_GetStr255, resName))
        return NULL;
    FlattenMovie(_self->ob_itself,
                 movieFlattenFlags,
                 &theFile,
                 creator,
                 scriptTag,
                 createMovieFileFlags,
                 &resId,
                 resName);
    _res = Py_BuildValue("h",
                         resId);
    return _res;
}

static PyObject *MovieObj_FlattenMovieData(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Movie _rv;
    long movieFlattenFlags;
    FSSpec theFile;
    OSType creator;
    ScriptCode scriptTag;
    long createMovieFileFlags;
    if (!PyArg_ParseTuple(_args, "lO&O&hl",
                          &movieFlattenFlags,
                          PyMac_GetFSSpec, &theFile,
                          PyMac_GetOSType, &creator,
                          &scriptTag,
                          &createMovieFileFlags))
        return NULL;
    _rv = FlattenMovieData(_self->ob_itself,
                           movieFlattenFlags,
                           &theFile,
                           creator,
                           scriptTag,
                           createMovieFileFlags);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_MovieSearchText(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Ptr text;
    long size;
    long searchFlags;
    Track searchTrack;
    TimeValue searchTime;
    long searchOffset;
    if (!PyArg_ParseTuple(_args, "sll",
                          &text,
                          &size,
                          &searchFlags))
        return NULL;
    _err = MovieSearchText(_self->ob_itself,
                           text,
                           size,
                           searchFlags,
                           &searchTrack,
                           &searchTime,
                           &searchOffset);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&ll",
                         TrackObj_New, searchTrack,
                         searchTime,
                         searchOffset);
    return _res;
}

static PyObject *MovieObj_GetPosterBox(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Rect boxRect;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    GetPosterBox(_self->ob_itself,
                 &boxRect);
    _res = Py_BuildValue("O&",
                         PyMac_BuildRect, &boxRect);
    return _res;
}

static PyObject *MovieObj_SetPosterBox(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Rect boxRect;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetRect, &boxRect))
        return NULL;
    SetPosterBox(_self->ob_itself,
                 &boxRect);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_GetMovieSegmentDisplayBoundsRgn(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    RgnHandle _rv;
    TimeValue time;
    TimeValue duration;
    if (!PyArg_ParseTuple(_args, "ll",
                          &time,
                          &duration))
        return NULL;
    _rv = GetMovieSegmentDisplayBoundsRgn(_self->ob_itself,
                                          time,
                                          duration);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_GetMovieStatus(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    Track firstProblemTrack;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMovieStatus(_self->ob_itself,
                         &firstProblemTrack);
    _res = Py_BuildValue("lO&",
                         _rv,
                         TrackObj_New, firstProblemTrack);
    return _res;
}

static PyObject *MovieObj_NewMovieController(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    MovieController _rv;
    Rect movieRect;
    long someFlags;
    if (!PyArg_ParseTuple(_args, "O&l",
                          PyMac_GetRect, &movieRect,
                          &someFlags))
        return NULL;
    _rv = NewMovieController(_self->ob_itself,
                             &movieRect,
                             someFlags);
    _res = Py_BuildValue("O&",
                         MovieCtlObj_New, _rv);
    return _res;
}

static PyObject *MovieObj_PutMovieOnScrap(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    long movieScrapFlags;
    if (!PyArg_ParseTuple(_args, "l",
                          &movieScrapFlags))
        return NULL;
    _err = PutMovieOnScrap(_self->ob_itself,
                           movieScrapFlags);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MovieObj_SetMoviePlayHints(_self, _args)
    MovieObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    long flags;
    long flagsMask;
    if (!PyArg_ParseTuple(_args, "ll",
                          &flags,
                          &flagsMask))
        return NULL;
    SetMoviePlayHints(_self->ob_itself,
                      flags,
                      flagsMask);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyMethodDef MovieObj_methods[] = {
    {"MoviesTask", (PyCFunction)MovieObj_MoviesTask, 1,
     "(long maxMilliSecToUse) -> None"},
    {"PrerollMovie", (PyCFunction)MovieObj_PrerollMovie, 1,
     "(TimeValue time, Fixed Rate) -> None"},
    {"LoadMovieIntoRam", (PyCFunction)MovieObj_LoadMovieIntoRam, 1,
     "(TimeValue time, TimeValue duration, long flags) -> None"},
    {"SetMovieActive", (PyCFunction)MovieObj_SetMovieActive, 1,
     "(Boolean active) -> None"},
    {"GetMovieActive", (PyCFunction)MovieObj_GetMovieActive, 1,
     "() -> (Boolean _rv)"},
    {"StartMovie", (PyCFunction)MovieObj_StartMovie, 1,
     "() -> None"},
    {"StopMovie", (PyCFunction)MovieObj_StopMovie, 1,
     "() -> None"},
    {"GoToBeginningOfMovie", (PyCFunction)MovieObj_GoToBeginningOfMovie, 1,
     "() -> None"},
    {"GoToEndOfMovie", (PyCFunction)MovieObj_GoToEndOfMovie, 1,
     "() -> None"},
    {"IsMovieDone", (PyCFunction)MovieObj_IsMovieDone, 1,
     "() -> (Boolean _rv)"},
    {"GetMoviePreviewMode", (PyCFunction)MovieObj_GetMoviePreviewMode, 1,
     "() -> (Boolean _rv)"},
    {"SetMoviePreviewMode", (PyCFunction)MovieObj_SetMoviePreviewMode, 1,
     "(Boolean usePreview) -> None"},
    {"ShowMoviePoster", (PyCFunction)MovieObj_ShowMoviePoster, 1,
     "() -> None"},
    {"GetMovieTimeBase", (PyCFunction)MovieObj_GetMovieTimeBase, 1,
     "() -> (TimeBase _rv)"},
    {"GetNextTrackForCompositing", (PyCFunction)MovieObj_GetNextTrackForCompositing, 1,
     "(Track theTrack) -> (Track _rv)"},
    {"GetPrevTrackForCompositing", (PyCFunction)MovieObj_GetPrevTrackForCompositing, 1,
     "(Track theTrack) -> (Track _rv)"},
    {"GetMoviePict", (PyCFunction)MovieObj_GetMoviePict, 1,
     "(TimeValue time) -> (PicHandle _rv)"},
    {"GetMoviePosterPict", (PyCFunction)MovieObj_GetMoviePosterPict, 1,
     "() -> (PicHandle _rv)"},
    {"UpdateMovie", (PyCFunction)MovieObj_UpdateMovie, 1,
     "() -> None"},
    {"GetMovieBox", (PyCFunction)MovieObj_GetMovieBox, 1,
     "() -> (Rect boxRect)"},
    {"SetMovieBox", (PyCFunction)MovieObj_SetMovieBox, 1,
     "(Rect boxRect) -> None"},
    {"GetMovieDisplayClipRgn", (PyCFunction)MovieObj_GetMovieDisplayClipRgn, 1,
     "() -> (RgnHandle _rv)"},
    {"SetMovieDisplayClipRgn", (PyCFunction)MovieObj_SetMovieDisplayClipRgn, 1,
     "(RgnHandle theClip) -> None"},
    {"GetMovieClipRgn", (PyCFunction)MovieObj_GetMovieClipRgn, 1,
     "() -> (RgnHandle _rv)"},
    {"SetMovieClipRgn", (PyCFunction)MovieObj_SetMovieClipRgn, 1,
     "(RgnHandle theClip) -> None"},
    {"GetMovieDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieDisplayBoundsRgn, 1,
     "() -> (RgnHandle _rv)"},
    {"GetMovieBoundsRgn", (PyCFunction)MovieObj_GetMovieBoundsRgn, 1,
     "() -> (RgnHandle _rv)"},
    {"PutMovieIntoHandle", (PyCFunction)MovieObj_PutMovieIntoHandle, 1,
     "(Handle publicMovie) -> None"},
    {"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1,
     "(short fRefNum, long offset, long maxSize) -> None"},
    {"GetMovieTimeScale", (PyCFunction)MovieObj_GetMovieTimeScale, 1,
     "() -> (TimeScale _rv)"},
    {"SetMovieTimeScale", (PyCFunction)MovieObj_SetMovieTimeScale, 1,
     "(TimeScale timeScale) -> None"},
    {"GetMovieDuration", (PyCFunction)MovieObj_GetMovieDuration, 1,
     "() -> (TimeValue _rv)"},
    {"GetMovieRate", (PyCFunction)MovieObj_GetMovieRate, 1,
     "() -> (Fixed _rv)"},
    {"SetMovieRate", (PyCFunction)MovieObj_SetMovieRate, 1,
     "(Fixed rate) -> None"},
    {"GetMoviePreferredRate", (PyCFunction)MovieObj_GetMoviePreferredRate, 1,
     "() -> (Fixed _rv)"},
    {"SetMoviePreferredRate", (PyCFunction)MovieObj_SetMoviePreferredRate, 1,
     "(Fixed rate) -> None"},
    {"GetMoviePreferredVolume", (PyCFunction)MovieObj_GetMoviePreferredVolume, 1,
     "() -> (short _rv)"},
    {"SetMoviePreferredVolume", (PyCFunction)MovieObj_SetMoviePreferredVolume, 1,
     "(short volume) -> None"},
    {"GetMovieVolume", (PyCFunction)MovieObj_GetMovieVolume, 1,
     "() -> (short _rv)"},
    {"SetMovieVolume", (PyCFunction)MovieObj_SetMovieVolume, 1,
     "(short volume) -> None"},
    {"GetMoviePreviewTime", (PyCFunction)MovieObj_GetMoviePreviewTime, 1,
     "() -> (TimeValue previewTime, TimeValue previewDuration)"},
    {"SetMoviePreviewTime", (PyCFunction)MovieObj_SetMoviePreviewTime, 1,
     "(TimeValue previewTime, TimeValue previewDuration) -> None"},
    {"GetMoviePosterTime", (PyCFunction)MovieObj_GetMoviePosterTime, 1,
     "() -> (TimeValue _rv)"},
    {"SetMoviePosterTime", (PyCFunction)MovieObj_SetMoviePosterTime, 1,
     "(TimeValue posterTime) -> None"},
    {"GetMovieSelection", (PyCFunction)MovieObj_GetMovieSelection, 1,
     "() -> (TimeValue selectionTime, TimeValue selectionDuration)"},
    {"SetMovieSelection", (PyCFunction)MovieObj_SetMovieSelection, 1,
     "(TimeValue selectionTime, TimeValue selectionDuration) -> None"},
    {"SetMovieActiveSegment", (PyCFunction)MovieObj_SetMovieActiveSegment, 1,
     "(TimeValue startTime, TimeValue duration) -> None"},
    {"GetMovieActiveSegment", (PyCFunction)MovieObj_GetMovieActiveSegment, 1,
     "() -> (TimeValue startTime, TimeValue duration)"},
    {"SetMovieTimeValue", (PyCFunction)MovieObj_SetMovieTimeValue, 1,
     "(TimeValue newtime) -> None"},
    {"GetMovieUserData", (PyCFunction)MovieObj_GetMovieUserData, 1,
     "() -> (UserData _rv)"},
    {"GetMovieTrackCount", (PyCFunction)MovieObj_GetMovieTrackCount, 1,
     "() -> (long _rv)"},
    {"GetMovieTrack", (PyCFunction)MovieObj_GetMovieTrack, 1,
     "(long trackID) -> (Track _rv)"},
    {"GetMovieIndTrack", (PyCFunction)MovieObj_GetMovieIndTrack, 1,
     "(long index) -> (Track _rv)"},
    {"GetMovieIndTrackType", (PyCFunction)MovieObj_GetMovieIndTrackType, 1,
     "(long index, OSType trackType, long flags) -> (Track _rv)"},
    {"NewMovieTrack", (PyCFunction)MovieObj_NewMovieTrack, 1,
     "(Fixed width, Fixed height, short trackVolume) -> (Track _rv)"},
    {"SetAutoTrackAlternatesEnabled", (PyCFunction)MovieObj_SetAutoTrackAlternatesEnabled, 1,
     "(Boolean enable) -> None"},
    {"SelectMovieAlternates", (PyCFunction)MovieObj_SelectMovieAlternates, 1,
     "() -> None"},
    {"InsertMovieSegment", (PyCFunction)MovieObj_InsertMovieSegment, 1,
     "(Movie dstMovie, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None"},
    {"InsertEmptyMovieSegment", (PyCFunction)MovieObj_InsertEmptyMovieSegment, 1,
     "(TimeValue dstIn, TimeValue dstDuration) -> None"},
    {"DeleteMovieSegment", (PyCFunction)MovieObj_DeleteMovieSegment, 1,
     "(TimeValue startTime, TimeValue duration) -> None"},
    {"ScaleMovieSegment", (PyCFunction)MovieObj_ScaleMovieSegment, 1,
     "(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None"},
    {"CutMovieSelection", (PyCFunction)MovieObj_CutMovieSelection, 1,
     "() -> (Movie _rv)"},
    {"CopyMovieSelection", (PyCFunction)MovieObj_CopyMovieSelection, 1,
     "() -> (Movie _rv)"},
    {"PasteMovieSelection", (PyCFunction)MovieObj_PasteMovieSelection, 1,
     "(Movie src) -> None"},
    {"AddMovieSelection", (PyCFunction)MovieObj_AddMovieSelection, 1,
     "(Movie src) -> None"},
    {"ClearMovieSelection", (PyCFunction)MovieObj_ClearMovieSelection, 1,
     "() -> None"},
    {"PutMovieIntoTypedHandle", (PyCFunction)MovieObj_PutMovieIntoTypedHandle, 1,
     "(Track targetTrack, OSType handleType, Handle publicMovie, TimeValue start, TimeValue dur, long flags, ComponentInstance userComp) -> None"},
    {"CopyMovieSettings", (PyCFunction)MovieObj_CopyMovieSettings, 1,
     "(Movie dstMovie) -> None"},
    {"ConvertMovieToFile", (PyCFunction)MovieObj_ConvertMovieToFile, 1,
     "(Track onlyTrack, FSSpec outputFile, OSType fileType, OSType creator, ScriptCode scriptTag, long flags, ComponentInstance userComp) -> (short resID)"},
    {"GetMovieDataSize", (PyCFunction)MovieObj_GetMovieDataSize, 1,
     "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
    {"PtInMovie", (PyCFunction)MovieObj_PtInMovie, 1,
     "(Point pt) -> (Boolean _rv)"},
    {"SetMovieLanguage", (PyCFunction)MovieObj_SetMovieLanguage, 1,
     "(long language) -> None"},
    {"GetMovieNextInterestingTime", (PyCFunction)MovieObj_GetMovieNextInterestingTime, 1,
     "(short interestingTimeFlags, short numMediaTypes, OSType whichMediaTypes, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
    {"AddMovieResource", (PyCFunction)MovieObj_AddMovieResource, 1,
     "(short resRefNum, Str255 resName) -> (short resId)"},
    {"UpdateMovieResource", (PyCFunction)MovieObj_UpdateMovieResource, 1,
     "(short resRefNum, short resId, Str255 resName) -> None"},
    {"HasMovieChanged", (PyCFunction)MovieObj_HasMovieChanged, 1,
     "() -> (Boolean _rv)"},
    {"ClearMovieChanged", (PyCFunction)MovieObj_ClearMovieChanged, 1,
     "() -> None"},
    {"SetMovieDefaultDataRef", (PyCFunction)MovieObj_SetMovieDefaultDataRef, 1,
     "(Handle dataRef, OSType dataRefType) -> None"},
    {"GetMovieDefaultDataRef", (PyCFunction)MovieObj_GetMovieDefaultDataRef, 1,
     "() -> (Handle dataRef, OSType dataRefType)"},
    {"SetMovieColorTable", (PyCFunction)MovieObj_SetMovieColorTable, 1,
     "(CTabHandle ctab) -> None"},
    {"GetMovieColorTable", (PyCFunction)MovieObj_GetMovieColorTable, 1,
     "() -> (CTabHandle ctab)"},
    {"FlattenMovie", (PyCFunction)MovieObj_FlattenMovie, 1,
     "(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Str255 resName) -> (short resId)"},
    {"FlattenMovieData", (PyCFunction)MovieObj_FlattenMovieData, 1,
     "(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)"},
    {"MovieSearchText", (PyCFunction)MovieObj_MovieSearchText, 1,
     "(Ptr text, long size, long searchFlags) -> (Track searchTrack, TimeValue searchTime, long searchOffset)"},
    {"GetPosterBox", (PyCFunction)MovieObj_GetPosterBox, 1,
     "() -> (Rect boxRect)"},
    {"SetPosterBox", (PyCFunction)MovieObj_SetPosterBox, 1,
     "(Rect boxRect) -> None"},
    {"GetMovieSegmentDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieSegmentDisplayBoundsRgn, 1,
     "(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"},
    {"GetMovieStatus", (PyCFunction)MovieObj_GetMovieStatus, 1,
     "() -> (ComponentResult _rv, Track firstProblemTrack)"},
    {"NewMovieController", (PyCFunction)MovieObj_NewMovieController, 1,
     "(Rect movieRect, long someFlags) -> (MovieController _rv)"},
    {"PutMovieOnScrap", (PyCFunction)MovieObj_PutMovieOnScrap, 1,
     "(long movieScrapFlags) -> None"},
    {"SetMoviePlayHints", (PyCFunction)MovieObj_SetMoviePlayHints, 1,
     "(long flags, long flagsMask) -> None"},
    {NULL, NULL, 0}
};

PyMethodChain MovieObj_chain = { MovieObj_methods, NULL };

static PyObject *MovieObj_getattr(self, name)
    MovieObject *self;
    char *name;
{
    return Py_FindMethodInChain(&MovieObj_chain, (PyObject *)self, name);
}

#define MovieObj_setattr NULL

PyTypeObject Movie_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0, /*ob_size*/
    "Movie", /*tp_name*/
    sizeof(MovieObject), /*tp_basicsize*/
    0, /*tp_itemsize*/
    /* methods */
    (destructor) MovieObj_dealloc, /*tp_dealloc*/
    0, /*tp_print*/
    (getattrfunc) MovieObj_getattr, /*tp_getattr*/
    (setattrfunc) MovieObj_setattr, /*tp_setattr*/
};

/* --------------------- End object type Movie ---------------------- */


static PyObject *Qt_EnterMovies(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = EnterMovies();
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_ExitMovies(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    ExitMovies();
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_GetMoviesError(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetMoviesError();
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_ClearMoviesStickyError(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    ClearMoviesStickyError();
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_GetMoviesStickyError(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetMoviesStickyError();
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_DisposeMatte(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    PixMapHandle theMatte;
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &theMatte))
        return NULL;
    DisposeMatte(theMatte);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_NewMovie(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Movie _rv;
    long flags;
    if (!PyArg_ParseTuple(_args, "l",
                          &flags))
        return NULL;
    _rv = NewMovie(flags);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *Qt_GetDataHandler(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Component _rv;
    Handle dataRef;
    OSType dataHandlerSubType;
    long flags;
    if (!PyArg_ParseTuple(_args, "O&O&l",
                          ResObj_Convert, &dataRef,
                          PyMac_GetOSType, &dataHandlerSubType,
                          &flags))
        return NULL;
    _rv = GetDataHandler(dataRef,
                         dataHandlerSubType,
                         flags);
    _res = Py_BuildValue("O&",
                         CmpObj_New, _rv);
    return _res;
}

static PyObject *Qt_PasteHandleIntoMovie(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle h;
    OSType handleType;
    Movie theMovie;
    long flags;
    ComponentInstance userComp;
    if (!PyArg_ParseTuple(_args, "O&O&O&lO&",
                          ResObj_Convert, &h,
                          PyMac_GetOSType, &handleType,
                          MovieObj_Convert, &theMovie,
                          &flags,
                          CmpInstObj_Convert, &userComp))
        return NULL;
    _err = PasteHandleIntoMovie(h,
                                handleType,
                                theMovie,
                                flags,
                                userComp);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_TrackTimeToMediaTime(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeValue _rv;
    TimeValue value;
    Track theTrack;
    if (!PyArg_ParseTuple(_args, "lO&",
                          &value,
                          TrackObj_Convert, &theTrack))
        return NULL;
    _rv = TrackTimeToMediaTime(value,
                               theTrack);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_NewUserData(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    UserData theUserData;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = NewUserData(&theUserData);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         UserDataObj_New, theUserData);
    return _res;
}

static PyObject *Qt_NewUserDataFromHandle(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Handle h;
    UserData theUserData;
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &h))
        return NULL;
    _err = NewUserDataFromHandle(h,
                                 &theUserData);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         UserDataObj_New, theUserData);
    return _res;
}

static PyObject *Qt_CreateMovieFile(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    FSSpec fileSpec;
    OSType creator;
    ScriptCode scriptTag;
    long createMovieFileFlags;
    short resRefNum;
    Movie newmovie;
    if (!PyArg_ParseTuple(_args, "O&O&hl",
                          PyMac_GetFSSpec, &fileSpec,
                          PyMac_GetOSType, &creator,
                          &scriptTag,
                          &createMovieFileFlags))
        return NULL;
    _err = CreateMovieFile(&fileSpec,
                           creator,
                           scriptTag,
                           createMovieFileFlags,
                           &resRefNum,
                           &newmovie);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("hO&",
                         resRefNum,
                         MovieObj_New, newmovie);
    return _res;
}

static PyObject *Qt_OpenMovieFile(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    FSSpec fileSpec;
    short resRefNum;
    SInt8 permission;
    if (!PyArg_ParseTuple(_args, "O&b",
                          PyMac_GetFSSpec, &fileSpec,
                          &permission))
        return NULL;
    _err = OpenMovieFile(&fileSpec,
                         &resRefNum,
                         permission);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         resRefNum);
    return _res;
}

static PyObject *Qt_CloseMovieFile(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    short resRefNum;
    if (!PyArg_ParseTuple(_args, "h",
                          &resRefNum))
        return NULL;
    _err = CloseMovieFile(resRefNum);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_DeleteMovieFile(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    FSSpec fileSpec;
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetFSSpec, &fileSpec))
        return NULL;
    _err = DeleteMovieFile(&fileSpec);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_NewMovieFromFile(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie theMovie;
    short resRefNum;
    short newMovieFlags;
    Boolean dataRefWasChanged;
    if (!PyArg_ParseTuple(_args, "hh",
                          &resRefNum,
                          &newMovieFlags))
        return NULL;
    _err = NewMovieFromFile(&theMovie,
                            resRefNum,
                            (short *)0,
                            (StringPtr)0,
                            newMovieFlags,
                            &dataRefWasChanged);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&b",
                         MovieObj_New, theMovie,
                         dataRefWasChanged);
    return _res;
}

static PyObject *Qt_NewMovieFromHandle(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie theMovie;
    Handle h;
    short newMovieFlags;
    Boolean dataRefWasChanged;
    if (!PyArg_ParseTuple(_args, "O&h",
                          ResObj_Convert, &h,
                          &newMovieFlags))
        return NULL;
    _err = NewMovieFromHandle(&theMovie,
                              h,
                              newMovieFlags,
                              &dataRefWasChanged);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&b",
                         MovieObj_New, theMovie,
                         dataRefWasChanged);
    return _res;
}

static PyObject *Qt_NewMovieFromDataFork(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    Movie theMovie;
    short fRefNum;
    long fileOffset;
    short newMovieFlags;
    Boolean dataRefWasChanged;
    if (!PyArg_ParseTuple(_args, "hlh",
                          &fRefNum,
                          &fileOffset,
                          &newMovieFlags))
        return NULL;
    _err = NewMovieFromDataFork(&theMovie,
                                fRefNum,
                                fileOffset,
                                newMovieFlags,
                                &dataRefWasChanged);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&b",
                         MovieObj_New, theMovie,
                         dataRefWasChanged);
    return _res;
}

static PyObject *Qt_RemoveMovieResource(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    OSErr _err;
    short resRefNum;
    short resId;
    if (!PyArg_ParseTuple(_args, "hh",
                          &resRefNum,
                          &resId))
        return NULL;
    _err = RemoveMovieResource(resRefNum,
                               resId);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_GetVideoMediaGraphicsMode(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    HandlerError _rv;
    MediaHandler mh;
    long graphicsMode;
    RGBColor opColor;
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = GetVideoMediaGraphicsMode(mh,
                                    &graphicsMode,
                                    &opColor);
    _res = Py_BuildValue("llO&",
                         _rv,
                         graphicsMode,
                         QdRGB_New, &opColor);
    return _res;
}

static PyObject *Qt_SetVideoMediaGraphicsMode(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    HandlerError _rv;
    MediaHandler mh;
    long graphicsMode;
    RGBColor opColor;
    if (!PyArg_ParseTuple(_args, "O&lO&",
                          CmpInstObj_Convert, &mh,
                          &graphicsMode,
                          QdRGB_Convert, &opColor))
        return NULL;
    _rv = SetVideoMediaGraphicsMode(mh,
                                    graphicsMode,
                                    &opColor);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_GetSoundMediaBalance(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    HandlerError _rv;
    MediaHandler mh;
    short balance;
    if (!PyArg_ParseTuple(_args, "O&",
                          CmpInstObj_Convert, &mh))
        return NULL;
    _rv = GetSoundMediaBalance(mh,
                               &balance);
    _res = Py_BuildValue("lh",
                         _rv,
                         balance);
    return _res;
}

static PyObject *Qt_SetSoundMediaBalance(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    HandlerError _rv;
    MediaHandler mh;
    short balance;
    if (!PyArg_ParseTuple(_args, "O&h",
                          CmpInstObj_Convert, &mh,
                          &balance))
        return NULL;
    _rv = SetSoundMediaBalance(mh,
                               balance);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Qt_FindNextText(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    ComponentResult _rv;
    MediaHandler mh;
    Ptr text;
    long size;
    short findFlags;
    TimeValue startTime;
    TimeValue foundTime;
    TimeValue foundDuration;
    long offset;
    if (!PyArg_ParseTuple(_args, "O&slhl",
                          CmpInstObj_Convert, &mh,
                          &text,
                          &size,
                          &findFlags,
                          &startTime))
        return NULL;
    _rv = FindNextText(mh,
                       text,
                       size,
                       findFlags,
                       startTime,
                       &foundTime,
                       &foundDuration,
                       &offset);
    _res = Py_BuildValue("llll",
                         _rv,
                         foundTime,
                         foundDuration,
                         offset);
    return _res;
}

static PyObject *Qt_NewMovieFromScrap(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    Movie _rv;
    long newMovieFlags;
    if (!PyArg_ParseTuple(_args, "l",
                          &newMovieFlags))
        return NULL;
    _rv = NewMovieFromScrap(newMovieFlags);
    _res = Py_BuildValue("O&",
                         MovieObj_New, _rv);
    return _res;
}

static PyObject *Qt_NewTimeBase(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    TimeBase _rv;
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = NewTimeBase();
    _res = Py_BuildValue("O&",
                         TimeBaseObj_New, _rv);
    return _res;
}

static PyObject *Qt_AlignWindow(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    WindowPtr wp;
    Boolean front;
    if (!PyArg_ParseTuple(_args, "O&b",
                          WinObj_Convert, &wp,
                          &front))
        return NULL;
    AlignWindow(wp,
                front,
                (Rect *)0,
                (ICMAlignmentProcRecordPtr)0);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Qt_DragAlignedWindow(_self, _args)
    PyObject *_self;
    PyObject *_args;
{
    PyObject *_res = NULL;
    WindowPtr wp;
    Point startPt;
    Rect boundsRect;
    if (!PyArg_ParseTuple(_args, "O&O&O&",
                          WinObj_Convert, &wp,
                          PyMac_GetPoint, &startPt,
                          PyMac_GetRect, &boundsRect))
        return NULL;
    DragAlignedWindow(wp,
                      startPt,
                      &boundsRect,
                      (Rect *)0,
                      (ICMAlignmentProcRecordPtr)0);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyMethodDef Qt_methods[] = {
    {"EnterMovies", (PyCFunction)Qt_EnterMovies, 1,
     "() -> None"},
    {"ExitMovies", (PyCFunction)Qt_ExitMovies, 1,
     "() -> None"},
    {"GetMoviesError", (PyCFunction)Qt_GetMoviesError, 1,
     "() -> None"},
    {"ClearMoviesStickyError", (PyCFunction)Qt_ClearMoviesStickyError, 1,
     "() -> None"},
    {"GetMoviesStickyError", (PyCFunction)Qt_GetMoviesStickyError, 1,
     "() -> None"},
    {"DisposeMatte", (PyCFunction)Qt_DisposeMatte, 1,
     "(PixMapHandle theMatte) -> None"},
    {"NewMovie", (PyCFunction)Qt_NewMovie, 1,
     "(long flags) -> (Movie _rv)"},
    {"GetDataHandler", (PyCFunction)Qt_GetDataHandler, 1,
     "(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)"},
    {"PasteHandleIntoMovie", (PyCFunction)Qt_PasteHandleIntoMovie, 1,
     "(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None"},
    {"TrackTimeToMediaTime", (PyCFunction)Qt_TrackTimeToMediaTime, 1,
     "(TimeValue value, Track theTrack) -> (TimeValue _rv)"},
    {"NewUserData", (PyCFunction)Qt_NewUserData, 1,
     "() -> (UserData theUserData)"},
    {"NewUserDataFromHandle", (PyCFunction)Qt_NewUserDataFromHandle, 1,
     "(Handle h) -> (UserData theUserData)"},
    {"CreateMovieFile", (PyCFunction)Qt_CreateMovieFile, 1,
     "(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (short resRefNum, Movie newmovie)"},
    {"OpenMovieFile", (PyCFunction)Qt_OpenMovieFile, 1,
     "(FSSpec fileSpec, SInt8 permission) -> (short resRefNum)"},
    {"CloseMovieFile", (PyCFunction)Qt_CloseMovieFile, 1,
     "(short resRefNum) -> None"},
    {"DeleteMovieFile", (PyCFunction)Qt_DeleteMovieFile, 1,
     "(FSSpec fileSpec) -> None"},
    {"NewMovieFromFile", (PyCFunction)Qt_NewMovieFromFile, 1,
     "(short resRefNum, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
    {"NewMovieFromHandle", (PyCFunction)Qt_NewMovieFromHandle, 1,
     "(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
    {"NewMovieFromDataFork", (PyCFunction)Qt_NewMovieFromDataFork, 1,
     "(short fRefNum, long fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
    {"RemoveMovieResource", (PyCFunction)Qt_RemoveMovieResource, 1,
     "(short resRefNum, short resId) -> None"},
    {"GetVideoMediaGraphicsMode", (PyCFunction)Qt_GetVideoMediaGraphicsMode, 1,
     "(MediaHandler mh) -> (HandlerError _rv, long graphicsMode, RGBColor opColor)"},
    {"SetVideoMediaGraphicsMode", (PyCFunction)Qt_SetVideoMediaGraphicsMode, 1,
     "(MediaHandler mh, long graphicsMode, RGBColor opColor) -> (HandlerError _rv)"},
    {"GetSoundMediaBalance", (PyCFunction)Qt_GetSoundMediaBalance, 1,
     "(MediaHandler mh) -> (HandlerError _rv, short balance)"},
    {"SetSoundMediaBalance", (PyCFunction)Qt_SetSoundMediaBalance, 1,
     "(MediaHandler mh, short balance) -> (HandlerError _rv)"},
    {"FindNextText", (PyCFunction)Qt_FindNextText, 1,
     "(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)"},
    {"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1,
     "(long newMovieFlags) -> (Movie _rv)"},
    {"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1,
     "() -> (TimeBase _rv)"},
    {"AlignWindow", (PyCFunction)Qt_AlignWindow, 1,
     "(WindowPtr wp, Boolean front) -> None"},
    {"DragAlignedWindow", (PyCFunction)Qt_DragAlignedWindow, 1,
     "(WindowPtr wp, Point startPt, Rect boundsRect) -> None"},
    {NULL, NULL, 0}
};




void initQt()
{
    PyObject *m;
    PyObject *d;




    m = Py_InitModule("Qt", Qt_methods);
    d = PyModule_GetDict(m);
    Qt_Error = PyMac_GetOSErrException();
    if (Qt_Error == NULL ||
        PyDict_SetItemString(d, "Error", Qt_Error) != 0)
        Py_FatalError("can't initialize Qt.Error");
}

/* ========================= End module Qt ========================== */